[clang-tools-extra] [llvm] Add Static Analysis for Identifying Data Parallelism Using LLVM/Clang (PR #190511)
via llvm-commits
llvm-commits at lists.llvm.org
Sun Apr 5 04:57:54 PDT 2026
https://github.com/HITESH-S-P updated https://github.com/llvm/llvm-project/pull/190511
>From 6e041451e5f04db3db0b220b420a14795957e379 Mon Sep 17 00:00:00 2001
From: HITESH S P <hiteshsp2004 at gmail.com>
Date: Fri, 20 Jun 2025 22:50:06 +0530
Subject: [PATCH 1/4] Added static analysis tool to detect data parallelism in
C/C++ code
---
clang-tools-extra/CMakeLists.txt | 1 +
.../clang-data-parallel/CMakeLists.txt | 5 +
.../clang-data-parallel/DataParallelCheck.cpp | 249 ++++++++++++++++++
3 files changed, 255 insertions(+)
create mode 100644 clang-tools-extra/clang-data-parallel/CMakeLists.txt
create mode 100644 clang-tools-extra/clang-data-parallel/DataParallelCheck.cpp
diff --git a/clang-tools-extra/CMakeLists.txt b/clang-tools-extra/CMakeLists.txt
index 87050db4e0e75..419b2955c746a 100644
--- a/clang-tools-extra/CMakeLists.txt
+++ b/clang-tools-extra/CMakeLists.txt
@@ -30,6 +30,7 @@ add_subdirectory(clang-query)
add_subdirectory(include-cleaner)
add_subdirectory(pp-trace)
add_subdirectory(tool-template)
+add_subdirectory(clang-data-parallel)
option(CLANG_TOOLS_EXTRA_INCLUDE_DOCS "Generate build targets for the Clang Extra Tools docs."
${LLVM_INCLUDE_DOCS})
diff --git a/clang-tools-extra/clang-data-parallel/CMakeLists.txt b/clang-tools-extra/clang-data-parallel/CMakeLists.txt
new file mode 100644
index 0000000000000..8dd507cec72ef
--- /dev/null
+++ b/clang-tools-extra/clang-data-parallel/CMakeLists.txt
@@ -0,0 +1,5 @@
+add_llvm_tool(clang-data-parallel DataParallelCheck.cpp )
+
+target_link_libraries(clang-data-parallel PRIVATE clangAST clangBasic clangFrontend clangTooling clangToolingCore LLVMFrontendOpenMP LLVMSupport )
+
+set_target_properties(clang-data-parallel PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" )
\ No newline at end of file
diff --git a/clang-tools-extra/clang-data-parallel/DataParallelCheck.cpp b/clang-tools-extra/clang-data-parallel/DataParallelCheck.cpp
new file mode 100644
index 0000000000000..1a774ece332e4
--- /dev/null
+++ b/clang-tools-extra/clang-data-parallel/DataParallelCheck.cpp
@@ -0,0 +1,249 @@
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendAction.h"
+#include "clang/Tooling/Tooling.h"
+#include "clang/Tooling/CommonOptionsParser.h"
+#include "llvm/Support/CommandLine.h"
+#include <iostream>
+#include <unordered_set>
+
+using namespace clang;
+using namespace clang::tooling;
+
+static llvm::cl::OptionCategory MyToolCategory("clang-data-parallel options");
+
+static llvm::cl::opt<bool> AnalyzeDataParallelism("analyze-data-parallelism",
+ llvm::cl::desc("Enable data parallelism analysis"),
+ llvm::cl::cat(MyToolCategory));
+
+class DataParallelVisitor : public RecursiveASTVisitor<DataParallelVisitor> {
+public:
+ DataParallelVisitor(ASTContext &Ctx) : Context(&Ctx) {}
+
+ bool VisitFunctionDecl(FunctionDecl *FD) {
+ if (!AnalyzeDataParallelism)
+ return true;
+
+ // Skip non-user-defined functions
+ if (!isUserCode(FD) || !FD->hasBody() || FD->getBuiltinID() != 0 ||
+ FD->isInlined() || FD->getStorageClass() == SC_Extern) {
+ return true;
+ }
+
+ functionName = FD->getNameInfo().getName().getAsString();
+ hasDataParallelism = false;
+ foundDependentAccess = false;
+
+ TraverseStmt(FD->getBody());
+
+ if (hasDataParallelism && !foundDependentAccess) {
+ llvm::outs() << "Function '" << functionName
+ << "' has data parallelism: Independent loop iterations detected at line "
+ << loopLine << "\n";
+ } else {
+ llvm::outs() << "Function '" << functionName << "' does not have data parallelism\n";
+ }
+
+ return true;
+ }
+
+ bool VisitForStmt(ForStmt *FS) {
+ if (!AnalyzeDataParallelism) return true;
+
+ // Reset state for each loop
+ hasDataParallelism = false;
+ foundDependentAccess = false;
+ loopVar = nullptr;
+ hasValidAssignment = false;
+
+ // Check loop variable declaration
+ if (auto *InitStmt = dyn_cast_or_null<DeclStmt>(FS->getInit())) {
+ if (auto *VD = dyn_cast_or_null<VarDecl>(InitStmt->getSingleDecl())) {
+ loopVar = VD;
+
+ // Skip if loop has conditionals or is not simple
+ if (hasConditional(FS->getBody()) || !isSimpleLoop(FS)) {
+ return true;
+ }
+
+ TraverseStmt(FS->getBody());
+
+ if (hasValidAssignment && !foundDependentAccess) {
+ hasDataParallelism = true;
+ unsigned Line = Context->getSourceManager().getPresumedLineNumber(FS->getBeginLoc());
+ loopLine = std::to_string(Line);
+ }
+ }
+ }
+
+ return true;
+ }
+
+ bool VisitBinaryOperator(BinaryOperator *BO) {
+ if (!AnalyzeDataParallelism || !loopVar) return true;
+
+ if (BO->getOpcode() == BO_Assign) {
+ // Check LHS for array access with loop variable
+ if (auto *ASE = dyn_cast<ArraySubscriptExpr>(BO->getLHS()->IgnoreImpCasts())) {
+ if (auto *Idx = dyn_cast<DeclRefExpr>(ASE->getIdx()->IgnoreImpCasts())) {
+ if (Idx->getDecl() == loopVar) {
+ hasValidAssignment = true;
+ // Check RHS for dependent accesses
+ if (HasDependentAccess(BO->getRHS())) {
+ foundDependentAccess = true;
+ }
+ }
+ }
+ }
+ // Check if LHS itself introduces a dependency (e.g., data[i] = data[i-1] + data[i])
+ if (HasDependentAccess(BO->getLHS())) {
+ foundDependentAccess = true;
+ }
+ }
+
+ return true;
+ }
+
+private:
+ ASTContext *Context;
+ VarDecl *loopVar = nullptr;
+ std::string functionName;
+ std::string loopLine;
+ bool hasValidAssignment = false;
+ bool hasDataParallelism = false;
+ bool foundDependentAccess = false;
+
+ // Check if the declaration is in user code
+ bool isUserCode(const Decl *D) {
+ SourceManager &SM = Context->getSourceManager();
+ SourceLocation Loc = D->getLocation();
+ if (!Loc.isValid() || SM.isInSystemHeader(Loc)) {
+ return false;
+ }
+ return SM.isInMainFile(Loc);
+ }
+
+ // Check for conditional statements in loop body
+ bool hasConditional(Stmt *S) {
+ class ConditionalVisitor : public RecursiveASTVisitor<ConditionalVisitor> {
+ public:
+ bool VisitIfStmt(IfStmt *) { found = true; return false; }
+ bool VisitSwitchStmt(SwitchStmt *) { found = true; return false; }
+ bool found = false;
+ };
+
+ ConditionalVisitor CV;
+ CV.TraverseStmt(S);
+ return CV.found;
+ }
+
+ // Verify if loop is simple (e.g., i++ or i+=1)
+ bool isSimpleLoop(ForStmt *FS) {
+ if (!FS->getInc()) return false;
+
+ // Check increment (e.g., i++ or i+=1)
+ if (auto *UO = dyn_cast<UnaryOperator>(FS->getInc())) {
+ if (UO->getOpcode() != UO_PostInc && UO->getOpcode() != UO_PreInc) {
+ return false;
+ }
+ if (auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreImpCasts())) {
+ return DRE->getDecl() == loopVar;
+ }
+ } else if (auto *BO = dyn_cast<BinaryOperator>(FS->getInc())) {
+ if (BO->getOpcode() != BO_Assign && BO->getOpcode() != BO_AddAssign) {
+ return false;
+ }
+ if (auto *DRE = dyn_cast<DeclRefExpr>(BO->getLHS()->IgnoreImpCasts())) {
+ if (DRE->getDecl() != loopVar) return false;
+ if (BO->getOpcode() == BO_AddAssign) {
+ if (auto *IL = dyn_cast<IntegerLiteral>(BO->getRHS())) {
+ return IL->getValue().getSExtValue() == 1;
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+
+ // Check for dependent array accesses (e.g., data[i-1], data[i+1])
+ bool HasDependentAccess(Expr *E) {
+ class DependencyVisitor : public RecursiveASTVisitor<DependencyVisitor> {
+ public:
+ DependencyVisitor(VarDecl *LV) : loopVar(LV) {}
+
+ bool VisitArraySubscriptExpr(ArraySubscriptExpr *ASE) {
+ Expr *Idx = ASE->getIdx()->IgnoreImpCasts();
+ // Check if index involves loop variable with offset
+ if (auto *BO = dyn_cast<BinaryOperator>(Idx)) {
+ if (BO->getOpcode() == BO_Add || BO->getOpcode() == BO_Sub) {
+ Expr *LHS = BO->getLHS()->IgnoreImpCasts();
+ Expr *RHS = BO->getRHS()->IgnoreImpCasts();
+ if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
+ if (DRE->getDecl() == loopVar) {
+ if (auto *IL = dyn_cast<IntegerLiteral>(RHS)) {
+ int offset = IL->getValue().getSExtValue();
+ if (offset != 0) {
+ found = true;
+ return false;
+ }
+ }
+ }
+ }
+ }
+ }
+ // Check if index is directly the loop variable (no dependency)
+ if (auto *DRE = dyn_cast<DeclRefExpr>(Idx)) {
+ if (DRE->getDecl() == loopVar) {
+ return true; // Not a dependency
+ }
+ }
+ // Any other index expression could be complex, conservatively assume dependency
+ found = true;
+ return false;
+ }
+
+ bool found = false;
+ VarDecl *loopVar;
+ };
+
+ DependencyVisitor DV(loopVar);
+ DV.TraverseStmt(E);
+ return DV.found;
+ }
+};
+
+// AST Consumer
+class DataParallelConsumer : public ASTConsumer {
+public:
+ DataParallelConsumer(ASTContext &Ctx) : Visitor(Ctx) {}
+
+ void HandleTranslationUnit(ASTContext &Ctx) override {
+ Visitor.TraverseDecl(Ctx.getTranslationUnitDecl());
+ }
+
+private:
+ DataParallelVisitor Visitor;
+};
+
+// Frontend Action
+class DataParallelAction : public ASTFrontendAction {
+public:
+ std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, StringRef file) override {
+ return std::make_unique<DataParallelConsumer>(CI.getASTContext());
+ }
+};
+
+// Main
+int main(int argc, const char **argv) {
+ auto ExpectedParser = CommonOptionsParser::create(argc, argv, MyToolCategory);
+ if (!ExpectedParser) {
+ llvm::errs() << ExpectedParser.takeError();
+ return 1;
+ }
+ ClangTool Tool(ExpectedParser->getCompilations(), ExpectedParser->getSourcePathList());
+
+ // Run the tool, relying on CommonOptionsParser for error diagnostics
+ return Tool.run(newFrontendActionFactory<DataParallelAction>().get());
+}
\ No newline at end of file
>From b148658446af18f2f38b36434af97a586d05a41c Mon Sep 17 00:00:00 2001
From: HITESH S P <hiteshsp2004 at gmail.com>
Date: Sun, 5 Apr 2026 13:27:24 +0530
Subject: [PATCH 2/4] Test-cases added
---
.gitignore | 1 +
1000.c | 52710 +++++++++++++++++++++++++++++++++++++++++++++++++++
ai.c | 0
myheader.c | 8 +
test.c | 79 +
test.cpp | 45 +
z.txt | 133 +
7 files changed, 52976 insertions(+)
create mode 100644 1000.c
create mode 100644 ai.c
create mode 100644 myheader.c
create mode 100644 test.c
create mode 100644 test.cpp
create mode 100644 z.txt
diff --git a/.gitignore b/.gitignore
index fa133b2d09834..ea20511d7b835 100644
--- a/.gitignore
+++ b/.gitignore
@@ -85,5 +85,6 @@ pythonenv*
/clang/utils/analyzer/projects/*/PatchedSource
/clang/utils/analyzer/projects/*/ScanBuildResults
/clang/utils/analyzer/projects/*/RefScanBuildResults
+z.txt
# automodapi puts generated documentation files here.
/lldb/docs/python_api/
diff --git a/1000.c b/1000.c
new file mode 100644
index 0000000000000..0fb9ea8c09177
--- /dev/null
+++ b/1000.c
@@ -0,0 +1,52710 @@
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+
+
+
+
+
+#include <math.h>
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ int i;
+ for (i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop with sin(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
\ No newline at end of file
diff --git a/ai.c b/ai.c
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/myheader.c b/myheader.c
new file mode 100644
index 0000000000000..3048c4a715a50
--- /dev/null
+++ b/myheader.c
@@ -0,0 +1,8 @@
+// compute.c
+#include <stdio.h>
+
+void imported_function(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i] * data[i];
+ }
+}
diff --git a/test.c b/test.c
new file mode 100644
index 0000000000000..93c52c9b22297
--- /dev/null
+++ b/test.c
@@ -0,0 +1,79 @@
+#include <math.h>
+#include "./myheader.c"
+#include <stdio.h>
+
+void imported_function(float* data, int size);
+
+/* Function 1:independent iterations (non parallelizable) */
+void Function1(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ data[i] = sqrt(data[i]);
+ }
+ }
+}
+
+/* Function 2: Independent loop with sin and cos (parallelizable) */
+void Function2(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = sin(data[i]) + cos(data[i]);
+ }
+}
+
+/* Function 3:independent loop with sin(parallelizable) */
+void Function3(float* data, int size) {
+ int src=0;
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i]*2;
+ }
+}
+
+/* Function 4: Loop with data dependency (not parallelizable) */
+void Functino4(float* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + data[i];
+ }
+}
+
+/* Function 5:independent loop for 2D(parallelizable) */
+void Function5(float** data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i][i] = data[i][i]*2;
+ }
+}
+
+//Function 6: Loop with data dependency (not parallelizable)
+void Function6(float* data, int size) {
+ int src;
+ for (int i = 0; i < size; i++) {
+ src = src + data[i];
+ }
+}
+
+//Function 7: Empty Loop
+void Function7(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i*2] * 2.0f;
+ }
+}
+
+// Function 8: Nested loops (parallelizable)
+void Function8(float* data, int size) {
+ for (int i = 0; i < size; i++) {
+ }
+}
+
+// Function 9:trial in final selection round
+int arr[10] = {0,1,2,3,4,5,6,7,8,9};
+void final(float* data, int size) {
+ for (int i = 0; i < 5; i++) {
+ data[i] = arr[i]*arr[i];
+ }
+}
+
+void trail(float* data,int size){
+ int src =0;
+ for(int i=0;i<size;i++){
+ src += data[i];
+ }
+}
diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000000000..ca1ecad987c2b
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,45 @@
+// Function 1: Independent loop iterations (parallelizable)
+void independent_loop(int* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i] * 2;
+ }
+}
+// Function 2: Loop with data dependency (not parallelizable)
+void dependent_loop(int* data, int size) {
+ for (int i = 1; i < size; i++) {
+ data[i] = data[i - 1] + 1;
+ }
+}
+// Function 3: Nested loops
+void nested_loop(int* data, int size) {
+ for (int i = 0; i < size; i++) {
+ for (int j = 0; j < 10; j++) {
+ data[i] += j;
+ }
+ }
+}
+// Function 4: Independent loop with array access (parallelizable)
+void sqr_function(int* data, int size) {
+ for (int i = 0; i < size; i++) {
+ data[i] = data[i] * data[i];
+ }
+}
+// Function 5: Loop with conditional dependency (not parallelizable)
+void conditional_loop(int* data, int size) {
+ int sum = 0;
+ for (int i = 0; i < size; i++) {
+ if (data[i] > 0) {
+ sum += data[i];
+ }
+ data[i] = sum;
+ }
+}
+
+
+//Function 7:
+int arr[10] = {0,1,2,3,4,5,6,7,8,9};
+void final(int* data, int size) {
+ for (int i = 0; i < 5; i++) {
+ data[i] = arr[data[i]];
+ }
+}
\ No newline at end of file
diff --git a/z.txt b/z.txt
new file mode 100644
index 0000000000000..4b5a258bb99b1
--- /dev/null
+++ b/z.txt
@@ -0,0 +1,133 @@
+#if condition - words
+#doubl for loop - wont work
+#access of neighbours - works
+#no operation - wont work
+#repeated access - works
+
+
+
+
+
+
+
+
+
+
+
+
+
+#building
+cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" -DLLVM_BUILD_TOOLS=ON -S ..\llvm -B .
+ninja clang-data-parallel
+
+
+
+
+
+
+
+
+
+
+
+
+#executable file
+D:\6_RVCE\CD\try\CD-lab-llvm-final\llvm-project\build\bin\clang-data-parallel.exe
+
+
+
+
+
+
+
+
+
+
+
+
+
+#running
+./bin/clang-data-parallel.exe -analyze-data-parallelism ../test.cpp -- -std=c++17
+./bin/clang-data-parallel.exe -analyze-data-parallelism ../test.c -- -std=c11
+
+
+
+
+
+
+
+
+
+
+
+
+
+#changed files
+llvm-project\clang-tools-extra\clang-data-parallel\CMakeLists.txt
+llvm-project\clang-tools-extra\clang-data-parallel\DataParallelCheck.cpp
+llvm-project\clang-tools-extra\CMakeLists.txt
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//compilation
+D:/6_RVCE/CD/try/CD-lab-llvm-final/llvm-project/clang/include/clang/Serialization/ASTReader.h:306:8: note: by 'virtual bool clang::ChainedASTReaderListener::visitInputFile(llvm::StringRef, bool, bool, bool)'
+D:/6_RVCE/CD/try/CD-lab-llvm-final/llvm-project/clang/include/clang/Serialization/ASTReader.h:306:8: note: by 'virtual bool clang::ChainedASTReaderListener::visitInputFile(llvm::StringRef, bool, bool, bool)'
+tInputFile(llvm::StringRef, bool, bool, bool)'
+ 306 | bool visitInputFile(StringRef Filename, bool isSystem,
+ | ^~~~~~~~~~~~~~
+[1867/1867] Linking CXX executable bin\clang-data-parallel.exe
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//building
+-- Compiling and running to test HAVE_STEADY_CLOCK
+-- Performing Test HAVE_STEADY_CLOCK -- success
+-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
+-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success
+-- Found Threads: TRUE
+-- Compiling and running to test HAVE_PTHREAD_AFFINITY
+-- Performing Test HAVE_PTHREAD_AFFINITY -- failed to compile
+-- Configuring done (203.3s)
+-- Generating done (73.1s)
+-- Build files have been written to: D:/6_RVCE/CD/CD-final/llvm-project/build
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//feedback
+admin - https://docs.google.com/forms/d/1ES5UGLjHcWSwu_oXh78_42-MXxJlo9HdEgmAF-O0fYI/edit
+user - https://docs.google.com/forms/d/e/1FAIpQLSf2xQgdEZsiJS07kECbOK0vDoGPHiKh-bsB_0ijG5mGP4z3Hg/viewform?usp=header
\ No newline at end of file
>From bfa6093f55123855ab5bf20fde005342063017e7 Mon Sep 17 00:00:00 2001
From: HITESH S P <hiteshsp2004 at gmail.com>
Date: Sun, 5 Apr 2026 13:40:10 +0530
Subject: [PATCH 3/4] Test-cases updated
---
z.txt | 133 ----------------------------------------------------------
1 file changed, 133 deletions(-)
diff --git a/z.txt b/z.txt
index 4b5a258bb99b1..e69de29bb2d1d 100644
--- a/z.txt
+++ b/z.txt
@@ -1,133 +0,0 @@
-#if condition - words
-#doubl for loop - wont work
-#access of neighbours - works
-#no operation - wont work
-#repeated access - works
-
-
-
-
-
-
-
-
-
-
-
-
-
-#building
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" -DLLVM_BUILD_TOOLS=ON -S ..\llvm -B .
-ninja clang-data-parallel
-
-
-
-
-
-
-
-
-
-
-
-
-#executable file
-D:\6_RVCE\CD\try\CD-lab-llvm-final\llvm-project\build\bin\clang-data-parallel.exe
-
-
-
-
-
-
-
-
-
-
-
-
-
-#running
-./bin/clang-data-parallel.exe -analyze-data-parallelism ../test.cpp -- -std=c++17
-./bin/clang-data-parallel.exe -analyze-data-parallelism ../test.c -- -std=c11
-
-
-
-
-
-
-
-
-
-
-
-
-
-#changed files
-llvm-project\clang-tools-extra\clang-data-parallel\CMakeLists.txt
-llvm-project\clang-tools-extra\clang-data-parallel\DataParallelCheck.cpp
-llvm-project\clang-tools-extra\CMakeLists.txt
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//compilation
-D:/6_RVCE/CD/try/CD-lab-llvm-final/llvm-project/clang/include/clang/Serialization/ASTReader.h:306:8: note: by 'virtual bool clang::ChainedASTReaderListener::visitInputFile(llvm::StringRef, bool, bool, bool)'
-D:/6_RVCE/CD/try/CD-lab-llvm-final/llvm-project/clang/include/clang/Serialization/ASTReader.h:306:8: note: by 'virtual bool clang::ChainedASTReaderListener::visitInputFile(llvm::StringRef, bool, bool, bool)'
-tInputFile(llvm::StringRef, bool, bool, bool)'
- 306 | bool visitInputFile(StringRef Filename, bool isSystem,
- | ^~~~~~~~~~~~~~
-[1867/1867] Linking CXX executable bin\clang-data-parallel.exe
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//building
--- Compiling and running to test HAVE_STEADY_CLOCK
--- Performing Test HAVE_STEADY_CLOCK -- success
--- Performing Test CMAKE_HAVE_LIBC_PTHREAD
--- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success
--- Found Threads: TRUE
--- Compiling and running to test HAVE_PTHREAD_AFFINITY
--- Performing Test HAVE_PTHREAD_AFFINITY -- failed to compile
--- Configuring done (203.3s)
--- Generating done (73.1s)
--- Build files have been written to: D:/6_RVCE/CD/CD-final/llvm-project/build
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//feedback
-admin - https://docs.google.com/forms/d/1ES5UGLjHcWSwu_oXh78_42-MXxJlo9HdEgmAF-O0fYI/edit
-user - https://docs.google.com/forms/d/e/1FAIpQLSf2xQgdEZsiJS07kECbOK0vDoGPHiKh-bsB_0ijG5mGP4z3Hg/viewform?usp=header
\ No newline at end of file
>From abfec345f3f0ae6258903cddb6bba6aac5f81d43 Mon Sep 17 00:00:00 2001
From: HITESH S P <hiteshsp2004 at gmail.com>
Date: Sun, 5 Apr 2026 17:26:17 +0530
Subject: [PATCH 4/4] Unwanted code removed
---
1000.c | 52710 ---------------------------------------------------
ai.c | 0
myheader.c | 8 -
test.c | 79 -
test.cpp | 45 -
z.txt | 0
6 files changed, 52842 deletions(-)
delete mode 100644 1000.c
delete mode 100644 ai.c
delete mode 100644 myheader.c
delete mode 100644 test.c
delete mode 100644 test.cpp
delete mode 100644 z.txt
diff --git a/1000.c b/1000.c
deleted file mode 100644
index 0fb9ea8c09177..0000000000000
--- a/1000.c
+++ /dev/null
@@ -1,52710 +0,0 @@
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-
-
-
-
-
-#include <math.h>
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- int i;
- for (i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop with sin(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 0; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
\ No newline at end of file
diff --git a/ai.c b/ai.c
deleted file mode 100644
index e69de29bb2d1d..0000000000000
diff --git a/myheader.c b/myheader.c
deleted file mode 100644
index 3048c4a715a50..0000000000000
--- a/myheader.c
+++ /dev/null
@@ -1,8 +0,0 @@
-// compute.c
-#include <stdio.h>
-
-void imported_function(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = data[i] * data[i];
- }
-}
diff --git a/test.c b/test.c
deleted file mode 100644
index 93c52c9b22297..0000000000000
--- a/test.c
+++ /dev/null
@@ -1,79 +0,0 @@
-#include <math.h>
-#include "./myheader.c"
-#include <stdio.h>
-
-void imported_function(float* data, int size);
-
-/* Function 1:independent iterations (non parallelizable) */
-void Function1(float* data, int size) {
- for (int i = 0; i < size; i++) {
- if (data[i] > 0) {
- data[i] = sqrt(data[i]);
- }
- }
-}
-
-/* Function 2: Independent loop with sin and cos (parallelizable) */
-void Function2(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = sin(data[i]) + cos(data[i]);
- }
-}
-
-/* Function 3:independent loop with sin(parallelizable) */
-void Function3(float* data, int size) {
- int src=0;
- for (int i = 0; i < size; i++) {
- data[i] = data[i]*2;
- }
-}
-
-/* Function 4: Loop with data dependency (not parallelizable) */
-void Functino4(float* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + data[i];
- }
-}
-
-/* Function 5:independent loop for 2D(parallelizable) */
-void Function5(float** data, int size) {
- for (int i = 1; i < size; i++) {
- data[i][i] = data[i][i]*2;
- }
-}
-
-//Function 6: Loop with data dependency (not parallelizable)
-void Function6(float* data, int size) {
- int src;
- for (int i = 0; i < size; i++) {
- src = src + data[i];
- }
-}
-
-//Function 7: Empty Loop
-void Function7(float* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = data[i*2] * 2.0f;
- }
-}
-
-// Function 8: Nested loops (parallelizable)
-void Function8(float* data, int size) {
- for (int i = 0; i < size; i++) {
- }
-}
-
-// Function 9:trial in final selection round
-int arr[10] = {0,1,2,3,4,5,6,7,8,9};
-void final(float* data, int size) {
- for (int i = 0; i < 5; i++) {
- data[i] = arr[i]*arr[i];
- }
-}
-
-void trail(float* data,int size){
- int src =0;
- for(int i=0;i<size;i++){
- src += data[i];
- }
-}
diff --git a/test.cpp b/test.cpp
deleted file mode 100644
index ca1ecad987c2b..0000000000000
--- a/test.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// Function 1: Independent loop iterations (parallelizable)
-void independent_loop(int* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = data[i] * 2;
- }
-}
-// Function 2: Loop with data dependency (not parallelizable)
-void dependent_loop(int* data, int size) {
- for (int i = 1; i < size; i++) {
- data[i] = data[i - 1] + 1;
- }
-}
-// Function 3: Nested loops
-void nested_loop(int* data, int size) {
- for (int i = 0; i < size; i++) {
- for (int j = 0; j < 10; j++) {
- data[i] += j;
- }
- }
-}
-// Function 4: Independent loop with array access (parallelizable)
-void sqr_function(int* data, int size) {
- for (int i = 0; i < size; i++) {
- data[i] = data[i] * data[i];
- }
-}
-// Function 5: Loop with conditional dependency (not parallelizable)
-void conditional_loop(int* data, int size) {
- int sum = 0;
- for (int i = 0; i < size; i++) {
- if (data[i] > 0) {
- sum += data[i];
- }
- data[i] = sum;
- }
-}
-
-
-//Function 7:
-int arr[10] = {0,1,2,3,4,5,6,7,8,9};
-void final(int* data, int size) {
- for (int i = 0; i < 5; i++) {
- data[i] = arr[data[i]];
- }
-}
\ No newline at end of file
diff --git a/z.txt b/z.txt
deleted file mode 100644
index e69de29bb2d1d..0000000000000
More information about the llvm-commits
mailing list