Add FirstQuestion Code

integral.c

+#include <stdio.h>
+#include <math.h>
+#include <omp.h>
+
+// Define the function f(x) = ln(x) / x
+double lnFunction(double x) {
+    return log(x) / x; 
+}
+
+double calculate_integral(int num_rectangles, double start, double end) {
+    double width = (end - start) / num_rectangles;
+    double total_area = 0.0;
+
+    #pragma omp parallel for reduction(+:total_area)
+    for (int i = 0; i < num_rectangles; i++) {
+        // Midpoint for rectangle
+        double x = start + (i + 0.5) * width;  
+        double area = lnFunction(x) * width;
+        total_area += area;
+    }
+
+    return total_area;
+}
+
+int main(int argc, char *argv[]) {
+    // Adjust for higher precision
+    int num_rectangles = 1000000;  
+
+    // integration interval
+    double start = 1.0, end = 10.0;
+
+    // Start time for performance measurement
+    double start_time = omp_get_wtime(); 
+    double total_area = calculate_integral(num_rectangles, start, end);
+    
+    // End time for performance measurement
+    double end_time = omp_get_wtime(); 
+
+    printf("Calculated integral: %.10f\n", total_area);
+    printf("Execution time: %.4f seconds\n", end_time - start_time);
+
+    return 0;
+}

integral_profile.txt

+Flat profile:
+
+Each sample counts as 0.01 seconds.
+  %   cumulative   self              self     total           
+ time   seconds   seconds    calls  ms/call  ms/call  name    
+ 50.00      0.01     0.01        2     5.00     5.00  __gcc_deregister_frame
+ 50.00      0.02     0.01                             __logl_internal
+  0.00      0.02     0.00        1     0.00     0.00  calculate_integral
+
+ %         the percentage of the total running time of the
+time       program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds   for by this function and those listed above it.
+
+ self      the number of seconds accounted for by this
+seconds    function alone.  This is the major sort for this
+           listing.
+
+calls      the number of times this function was invoked, if
+           this function is profiled, else blank.
+
+ self      the average number of milliseconds spent in this
+ms/call    function per call, if this function is profiled,
+	   else blank.
+
+ total     the average number of milliseconds spent in this
+ms/call    function and its descendents per call, if this
+	   function is profiled, else blank.
+
+name       the name of the function.  This is the minor sort
+           for this listing. The index shows the location of
+	   the function in the gprof listing. If the index is
+	   in parenthesis it shows where it would appear in
+	   the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2019 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+		     Call graph (explanation follows)
+
+
+granularity: each sample hit covers 4 byte(s) for 50.00% of 0.02 seconds
+
+index % time    self  children    called     name
+                0.01    0.00       1/2           GOMP_parallel [3]
+                0.01    0.00       1/2           gomp_thread_start [4]
+[1]     50.0    0.01    0.00       2         __gcc_deregister_frame [1]
+-----------------------------------------------
+                                                 <spontaneous>
+[2]     50.0    0.01    0.00                 __logl_internal [2]
+-----------------------------------------------
+                                                 <spontaneous>
+[3]     25.0    0.00    0.01                 GOMP_parallel [3]
+                0.01    0.00       1/2           __gcc_deregister_frame [1]
+-----------------------------------------------
+                                                 <spontaneous>
+[4]     25.0    0.00    0.01                 gomp_thread_start [4]
+                0.01    0.00       1/2           __gcc_deregister_frame [1]
+-----------------------------------------------
+                0.00    0.00       1/1           main [272]
+[5]      0.0    0.00    0.00       1         calculate_integral [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines.  The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+     index	A unique number given to each element of the table.
+		Index numbers are sorted numerically.
+		The index number is printed next to every function name so
+		it is easier to look up where the function is in the table.
+
+     % time	This is the percentage of the `total' time that was spent
+		in this function and its children.  Note that due to
+		different viewpoints, functions excluded by options, etc,
+		these numbers will NOT add up to 100%.
+
+     self	This is the total amount of time spent in this function.
+
+     children	This is the total amount of time propagated into this
+		function by its children.
+
+     called	This is the number of times the function was called.
+		If the function called itself recursively, the number
+		only includes non-recursive calls, and is followed by
+		a `+' and the number of recursive calls.
+
+     name	The name of the current function.  The index number is
+		printed after it.  If the function is a member of a
+		cycle, the cycle number is printed between the
+		function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the function into this parent.
+
+     children	This is the amount of time that was propagated from
+		the function's children into this parent.
+
+     called	This is the number of times this parent called the
+		function `/' the total number of times the function
+		was called.  Recursive calls to the function are not
+		included in the number after the `/'.
+
+     name	This is the name of the parent.  The parent's index
+		number is printed after it.  If the parent is a
+		member of a cycle, the cycle number is printed between
+		the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+     self	This is the amount of time that was propagated directly
+		from the child into the function.
+
+     children	This is the amount of time that was propagated from the
+		child's children to the function.
+
+     called	This is the number of times the function called
+		this child `/' the total number of times the child
+		was called.  Recursive calls by the child are not
+		listed in the number after the `/'.
+
+     name	This is the name of the child.  The child's index
+		number is printed after it.  If the child is a
+		member of a cycle, the cycle number is printed
+		between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole.  This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2019 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+   [1] __gcc_deregister_frame  [2] __logl_internal         [5] calculate_integral