[clang-tools-extra] [llvm] Add Static Analysis for Identifying Data Parallelism Using LLVM/Clang (PR #190511)

[via cfe-commits]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-clang-tools-extra

Author: HITESH-S-P

<details>
<summary>Changes</summary>

# Add Data Parallelism Analysis Tool and `-analyze-data-parallelism` Flag

## Description
This PR introduces a Clang-based static analysis tool to identify C/C++ functions with data parallelism, enabling vectorization and SIMD execution for compute-intensive applications. The tool uses LLVM/Clang to analyze the AST, control flow, and data dependencies, detecting data-parallel patterns. A new `-analyze-data-parallelism` flag triggers the analysis, emitting diagnostics for identified functions.
Fixes #<!-- -->190508

## Implementation Details

### New Functionality
- **Flag**: `-analyze-data-parallelism` enables the analysis.
- **Output**: Terminal diagnostics, e.g.:
  ```
  Function '<function-name>' has data parallelism: Independent loop iterations detected at line <line-number>.
  ```

Testing with C programming file.
![testing-cfiles](https://github.com/user-attachments/assets/5c13553d-7213-43b9-823e-445698adfb71)

Testing with C++ programming file.
![testing-cppfiles](https://github.com/user-attachments/assets/757ebd3d-32d1-414f-83dd-5a0b0b271430)

## Building the Tool
>From the build directory (`llvm-project/build`):
```bash
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**: `llvm-project/build/bin/clang-data-parallel.exe`

## Running the Tool
For C++:
```bash
./bin/clang-data-parallel.exe -analyze-data-parallelism test.cpp -- -std=c++17
```
For C:
```bash
./bin/clang-data-parallel.exe -analyze-data-parallelism test.c -- -std=c11
```

## Example Output
Input (`test.c` or `test.cpp`):
```cpp
void compute(int* data, int size) {
    for (int i = 0; i < size; ++i) {
        data[i] = data[i] * 2; // Data-parallel
    }
}
void process(int* arr, int n) {
    for (int i = 0; i < n; ++i) {
        if (arr[i] % 2 == 0) { // Non-parallel due to conditional
            arr[i] = arr[i] + 1;
        }
    }
}
```
Output:
```
test.c:2:5: Function 'compute' has data parallelism: Independent loop iterations detected at line 3.
test.c:9:5: Function 'process' does not exhibit data parallelism in its loops.
```

## 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`


---

Patch is 1.17 MiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/190511.diff


10 Files Affected:

- (modified) .gitignore (+1) 
- (added) 1000.c (+52710) 
- (added) ai.c () 
- (modified) clang-tools-extra/CMakeLists.txt (+1) 
- (added) clang-tools-extra/clang-data-parallel/CMakeLists.txt (+5) 
- (added) clang-tools-extra/clang-data-parallel/DataParallelCheck.cpp (+249) 
- (added) myheader.c (+8) 
- (added) test.c (+79) 
- (added) test.cpp (+45) 
- (added) z.txt () 


``````````diff
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;
+    }
+}
+
+/* Functi...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/190511