diff --git a/analysis/statistics/115c8d9436c7845dc5d0c16cda53e13e79b22622.txt b/analysis/statistics/115c8d9436c7845dc5d0c16cda53e13e79b22622.txt new file mode 100644 index 000000000..3d5c55564 --- /dev/null +++ b/analysis/statistics/115c8d9436c7845dc5d0c16cda53e13e79b22622.txt @@ -0,0 +1,46 @@ + +changeset: 1355:115c8d9436c7845dc5d0c16cda53e13e79b22622 +char kNewtonVersion[] = "0.3-alpha-1355 (115c8d9436c7845dc5d0c16cda53e13e79b22622) (build 11-07-2022-16:54-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/2d24ed5798451ac68def03cf02bc44b18b36605b.txt b/analysis/statistics/2d24ed5798451ac68def03cf02bc44b18b36605b.txt new file mode 100644 index 000000000..1e2c98537 --- /dev/null +++ b/analysis/statistics/2d24ed5798451ac68def03cf02bc44b18b36605b.txt @@ -0,0 +1,46 @@ + +changeset: 1349:2d24ed5798451ac68def03cf02bc44b18b36605b +char kNewtonVersion[] = "0.3-alpha-1349 (2d24ed5798451ac68def03cf02bc44b18b36605b) (build 10-21-2022-17:48-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/2eed18286939bcaf583d5111180c35065f63abe0.txt b/analysis/statistics/2eed18286939bcaf583d5111180c35065f63abe0.txt new file mode 100644 index 000000000..feee697ee --- /dev/null +++ b/analysis/statistics/2eed18286939bcaf583d5111180c35065f63abe0.txt @@ -0,0 +1,46 @@ + +changeset: 1353:2eed18286939bcaf583d5111180c35065f63abe0 +char kNewtonVersion[] = "0.3-alpha-1353 (2eed18286939bcaf583d5111180c35065f63abe0) (build 11-07-2022-11:59-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/31c37c0ae6472ccab358e6303199f373e8ec1a7f.txt b/analysis/statistics/31c37c0ae6472ccab358e6303199f373e8ec1a7f.txt new file mode 100644 index 000000000..09e6b1ffa --- /dev/null +++ b/analysis/statistics/31c37c0ae6472ccab358e6303199f373e8ec1a7f.txt @@ -0,0 +1,46 @@ + +changeset: 1356:31c37c0ae6472ccab358e6303199f373e8ec1a7f +char kNewtonVersion[] = "0.3-alpha-1356 (31c37c0ae6472ccab358e6303199f373e8ec1a7f) (build 11-15-2022-12:45-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/37e3e14aa587a76701b68edea866e0b288a8f2f5.txt b/analysis/statistics/37e3e14aa587a76701b68edea866e0b288a8f2f5.txt new file mode 100644 index 000000000..e8b0552e8 --- /dev/null +++ b/analysis/statistics/37e3e14aa587a76701b68edea866e0b288a8f2f5.txt @@ -0,0 +1,5 @@ + +changeset: 1366:37e3e14aa587a76701b68edea866e0b288a8f2f5 +char kNewtonVersion[] = "0.3-alpha-1366 (37e3e14aa587a76701b68edea866e0b288a8f2f5) (build 02-15-2023-15:31-pei@pei-G5-5500-Linux-5.15.0-60-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt diff --git a/analysis/statistics/37fb639b16e1bab2a2c957a1b0a01cc296e3f4db.txt b/analysis/statistics/37fb639b16e1bab2a2c957a1b0a01cc296e3f4db.txt new file mode 100644 index 000000000..7d6fa6f9a --- /dev/null +++ b/analysis/statistics/37fb639b16e1bab2a2c957a1b0a01cc296e3f4db.txt @@ -0,0 +1,46 @@ + +changeset: 1356:37fb639b16e1bab2a2c957a1b0a01cc296e3f4db +char kNewtonVersion[] = "0.3-alpha-1356 (37fb639b16e1bab2a2c957a1b0a01cc296e3f4db) (build 11-07-2022-17:43-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/458b34a45dbc979c402c207723bc5198d03646e8.txt b/analysis/statistics/458b34a45dbc979c402c207723bc5198d03646e8.txt new file mode 100644 index 000000000..06089ddef --- /dev/null +++ b/analysis/statistics/458b34a45dbc979c402c207723bc5198d03646e8.txt @@ -0,0 +1,46 @@ + +changeset: 1357:458b34a45dbc979c402c207723bc5198d03646e8 +char kNewtonVersion[] = "0.3-alpha-1357 (458b34a45dbc979c402c207723bc5198d03646e8) (build 11-09-2022-15:59-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/5790e5b54acd60a035ebd43ff3ace04a6de41afb.txt b/analysis/statistics/5790e5b54acd60a035ebd43ff3ace04a6de41afb.txt new file mode 100644 index 000000000..38327c230 --- /dev/null +++ b/analysis/statistics/5790e5b54acd60a035ebd43ff3ace04a6de41afb.txt @@ -0,0 +1,46 @@ + +changeset: 1358:5790e5b54acd60a035ebd43ff3ace04a6de41afb +char kNewtonVersion[] = "0.3-alpha-1358 (5790e5b54acd60a035ebd43ff3ace04a6de41afb) (build 11-09-2022-20:52-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/5c4e01a4d429b5f1c27d2f79f9de90994169c343.txt b/analysis/statistics/5c4e01a4d429b5f1c27d2f79f9de90994169c343.txt new file mode 100644 index 000000000..da94b67e2 --- /dev/null +++ b/analysis/statistics/5c4e01a4d429b5f1c27d2f79f9de90994169c343.txt @@ -0,0 +1,46 @@ + +changeset: 1368:5c4e01a4d429b5f1c27d2f79f9de90994169c343 +char kNewtonVersion[] = "0.3-alpha-1368 (5c4e01a4d429b5f1c27d2f79f9de90994169c343) (build 12-20-2022-12:31-pei@pei-G5-5500-Linux-5.15.0-56-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/76d3967245344914e39b3eb79a3a89fedf82dec0.txt b/analysis/statistics/76d3967245344914e39b3eb79a3a89fedf82dec0.txt new file mode 100644 index 000000000..821a55ba4 --- /dev/null +++ b/analysis/statistics/76d3967245344914e39b3eb79a3a89fedf82dec0.txt @@ -0,0 +1,46 @@ + +changeset: 1363:76d3967245344914e39b3eb79a3a89fedf82dec0 +char kNewtonVersion[] = "0.3-alpha-1363 (76d3967245344914e39b3eb79a3a89fedf82dec0) (build 12-20-2022-13:49-pei@pei-G5-5500-Linux-5.15.0-56-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/8233e1e4129aa152a49219c2d00a6f1fcb8f785c.txt b/analysis/statistics/8233e1e4129aa152a49219c2d00a6f1fcb8f785c.txt new file mode 100644 index 000000000..e00e05228 --- /dev/null +++ b/analysis/statistics/8233e1e4129aa152a49219c2d00a6f1fcb8f785c.txt @@ -0,0 +1,46 @@ + +changeset: 1364:8233e1e4129aa152a49219c2d00a6f1fcb8f785c +char kNewtonVersion[] = "0.3-alpha-1364 (8233e1e4129aa152a49219c2d00a6f1fcb8f785c) (build 12-20-2022-17:21-pei@pei-G5-5500-Linux-5.15.0-56-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/d70ffa5096dd653aaa3cde3853ee90136acdc9c8.txt b/analysis/statistics/d70ffa5096dd653aaa3cde3853ee90136acdc9c8.txt new file mode 100644 index 000000000..b93503fbc --- /dev/null +++ b/analysis/statistics/d70ffa5096dd653aaa3cde3853ee90136acdc9c8.txt @@ -0,0 +1,46 @@ + +changeset: 1362:d70ffa5096dd653aaa3cde3853ee90136acdc9c8 +char kNewtonVersion[] = "0.3-alpha-1362 (d70ffa5096dd653aaa3cde3853ee90136acdc9c8) (build 12-20-2022-13:20-pei@pei-G5-5500-Linux-5.15.0-56-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/analysis/statistics/fda580867ec987f9fe22036428b812d69eb5496d.txt b/analysis/statistics/fda580867ec987f9fe22036428b812d69eb5496d.txt new file mode 100644 index 000000000..350594589 --- /dev/null +++ b/analysis/statistics/fda580867ec987f9fe22036428b812d69eb5496d.txt @@ -0,0 +1,46 @@ + +changeset: 1354:fda580867ec987f9fe22036428b812d69eb5496d +char kNewtonVersion[] = "0.3-alpha-1354 (fda580867ec987f9fe22036428b812d69eb5496d) (build 11-07-2022-15:53-pei@pei-G5-5500-Linux-5.15.0-52-generic-x86_64)"; +\n./src/noisy/noisy-linux-EN -O0 applications/noisy/helloWorld.n -s +\n./src/newton/newton-linux-EN -v 0 -eP applications/newton/invariants/ViolinWithTemperatureDependence-pigroups.nt + +Informational Report: +--------------------- +Invariant "ViolinWithTemperatureDependenceForPiGroups" has 2 unique kernels, each with 2 column(s)... + + Kernel 0 is a valid kernel: + + 1 1 + -0.5 -0 + 1 0 + 0.5 0 + 0 -1 + -0 -1 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 0, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^( 0) P5^(-0) + + Pi group 0, Pi 1 is: P0^(-0) P1^( 1) P2^( 0) P3^( 0) P4^(-1) P5^(-1) + + + Kernel 1 is a valid kernel: + + 1 0 + -0.5 1 + 1 -2 + 0.5 -1 + -0 -2 + 0 -2 + + + The ordering of parameters is: P1 P0 P3 P2 P4 P5 + + Pi group 1, Pi 0 is: P0^(-0.5) P1^( 1) P2^(0.5) P3^( 1) P4^(-0) P5^( 0) + + Pi group 1, Pi 1 is: P0^( 1) P1^( 0) P2^(-1) P3^(-2) P4^(-2) P5^(-2) + + + + diff --git a/applications/newton/llvm-ir/Makefile b/applications/newton/llvm-ir/Makefile index d4be0cfeb..b79716ee9 100644 --- a/applications/newton/llvm-ir/Makefile +++ b/applications/newton/llvm-ir/Makefile @@ -18,7 +18,7 @@ endif all: default -default: application.ll simple_control_flow.ll inferBound.ll inferBoundControlFlow.ll e_exp.ll sincosf.ll e_log.ll e_acosh.ll e_j0.ll e_y0.ll e_rem_pio2.ll benchmark_suite.ll phi_two_global_arrays.ll func_call.ll +default: application.ll simple_control_flow.ll inferBound.ll inferBoundControlFlow.ll e_exp.ll sincosf.ll e_log.ll e_acosh.ll e_j0.ll e_y0.ll e_rem_pio2.ll benchmark_suite.ll phi_two_global_arrays.ll vec_add.ll vec_add_8.ll func_call.ll %.ll : %.c @echo Compiling $*.c diff --git a/applications/newton/llvm-ir/c-files/vec_add.c b/applications/newton/llvm-ir/c-files/vec_add.c new file mode 100644 index 000000000..63f959785 --- /dev/null +++ b/applications/newton/llvm-ir/c-files/vec_add.c @@ -0,0 +1,81 @@ +/* + * compile with 'clang --target=aarch64-arm-none-eabi -O1 vec_add.c -o vec_add -fvectorize' + * */ + +#include +#include +#include +#include +#include + +typedef struct timespec timespec; +timespec diff(timespec start, timespec end) +{ + timespec temp; + if ((end.tv_nsec-start.tv_nsec)<0) { + temp.tv_sec = end.tv_sec-start.tv_sec-1; + temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec; + } else { + temp.tv_sec = end.tv_sec-start.tv_sec; + temp.tv_nsec = end.tv_nsec-start.tv_nsec; + } + return temp; +} + +timespec sum(timespec t1, timespec t2) { + timespec temp; + if (t1.tv_nsec + t2.tv_nsec >= 1000000000) { + temp.tv_sec = t1.tv_sec + t2.tv_sec + 1; + temp.tv_nsec = t1.tv_nsec + t2.tv_nsec - 1000000000; + } else { + temp.tv_sec = t1.tv_sec + t2.tv_sec; + temp.tv_nsec = t1.tv_nsec + t2.tv_nsec; + } + return temp; +} + +void printTimeSpec(timespec t, const char* prefix) { + printf("%s: %d.%09d\n", prefix, (int)t.tv_sec, (int)t.tv_nsec); +} + +timespec tic( ) +{ + timespec start_time; + clock_gettime(CLOCK_REALTIME, &start_time); + return start_time; +} + +void toc( timespec* start_time, const char* prefix ) +{ + timespec current_time; + clock_gettime(CLOCK_REALTIME, ¤t_time); + printTimeSpec( diff( *start_time, current_time ), prefix ); + *start_time = current_time; +} + +typedef int32_t bmx055fAcceleration; + +#define NUM 102400 + +void vec_add(bmx055fAcceleration *vec_A, bmx055fAcceleration *vec_B, bmx055fAcceleration *vec_C, int len_vec) { + int i; + for (i=0; i +#include +#include +#include +#include + +typedef struct timespec timespec; +timespec diff(timespec start, timespec end) +{ + timespec temp; + if ((end.tv_nsec-start.tv_nsec)<0) { + temp.tv_sec = end.tv_sec-start.tv_sec-1; + temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec; + } else { + temp.tv_sec = end.tv_sec-start.tv_sec; + temp.tv_nsec = end.tv_nsec-start.tv_nsec; + } + return temp; +} + +timespec sum(timespec t1, timespec t2) { + timespec temp; + if (t1.tv_nsec + t2.tv_nsec >= 1000000000) { + temp.tv_sec = t1.tv_sec + t2.tv_sec + 1; + temp.tv_nsec = t1.tv_nsec + t2.tv_nsec - 1000000000; + } else { + temp.tv_sec = t1.tv_sec + t2.tv_sec; + temp.tv_nsec = t1.tv_nsec + t2.tv_nsec; + } + return temp; +} + +void printTimeSpec(timespec t, const char* prefix) { + printf("%s: %d.%09d\n", prefix, (int)t.tv_sec, (int)t.tv_nsec); +} + +timespec tic( ) +{ + timespec start_time; + clock_gettime(CLOCK_REALTIME, &start_time); + return start_time; +} + +void toc( timespec* start_time, const char* prefix ) +{ + timespec current_time; + clock_gettime(CLOCK_REALTIME, ¤t_time); + printTimeSpec( diff( *start_time, current_time ), prefix ); + *start_time = current_time; +} + +#define NUM 102400 + +void vec_add(int8_t *vec_A, int8_t *vec_B, int8_t *vec_C, int len_vec) { + int i; + for (i=0; i #include -int64_t getCount(const std::string& string, size_t position) { - std::string substring; - substring = string.substr(0, position); - substring.erase( - std::remove_if(substring.begin(), - substring.end(), - static_cast(&ispunct)), - substring.end()); - substring.erase( - std::remove_if(substring.begin(), - substring.end(), - static_cast(&isspace)), - substring.end()); - return std::stoi(substring); +int64_t +getCount(const std::string & string, size_t position) +{ + std::string substring; + substring = string.substr(0, position); + substring.erase( + std::remove_if(substring.begin(), + substring.end(), + static_cast(&ispunct)), + substring.end()); + substring.erase( + std::remove_if(substring.begin(), + substring.end(), + static_cast(&isspace)), + substring.end()); + return std::stoi(substring); } -std::pair processData(const std::string test_case, const std::string params) { - std::string line; - size_t position; - int64_t inst_count, time_consumption; - - // perf command - std::string cmd = "make " + test_case; - system(cmd.data()); - cmd.clear(); - cmd = "perf stat -B ./main_out " + params; - - cmd += "if=/dev/zero of=/dev/null count=1000000"; - cmd += " 2>&1 | tee tmp.log"; - system(cmd.data()); - std::ifstream ifs("tmp.log"); - if (!ifs.is_open()) { - std::cout << "error opening tmp.log"; - assert(false); - } - - // process - while (getline(ifs, line)) { - position = line.find("instructions"); - if (position != std::string::npos) { - inst_count = getCount(line, position); - } - position = line.find("seconds time elapsed"); - if (position != std::string::npos) { - time_consumption = getCount(line, position); - continue; - } - } - - printf("%lu\t%lu\n", inst_count, time_consumption); - - ifs.close(); - - return std::make_pair(inst_count, time_consumption); +std::pair +processData(const std::string test_case, const std::string params) +{ + std::string line; + size_t position; + int64_t inst_count, time_consumption; + + // perf command + std::string cmd = "make " + test_case; + system(cmd.data()); + cmd.clear(); + cmd = "perf stat -B ./main_out " + params; + + cmd += "if=/dev/zero of=/dev/null count=1000000"; + cmd += " 2>&1 | tee tmp.log"; + system(cmd.data()); + std::ifstream ifs("tmp.log"); + if (!ifs.is_open()) + { + std::cout << "error opening tmp.log"; + assert(false); + } + + // process + while (getline(ifs, line)) + { + position = line.find("instructions"); + if (position != std::string::npos) + { + inst_count = getCount(line, position); + } + position = line.find("seconds time elapsed"); + if (position != std::string::npos) + { + time_consumption = getCount(line, position); + continue; + } + } + + printf("%lu\t%lu\n", inst_count, time_consumption); + + ifs.close(); + + return std::make_pair(inst_count, time_consumption); } -std::string change_nt_range(const std::string& cmd1, const std::string& cmd2, const std::vector& params) { - std::string param_str; - std::string change_nt_cmd; - param_str.clear(); - change_nt_cmd.clear(); - change_nt_cmd = cmd1; - // prepare parameters - for (const auto& pp : params) { - param_str += std::to_string(pp) + " "; - change_nt_cmd += std::to_string(pp) + " mjf, "; - } - - change_nt_cmd.erase(change_nt_cmd.end() - 2); - change_nt_cmd += cmd2; - system(change_nt_cmd.data()); - - return param_str; +std::string +change_nt_range(const std::string & cmd1, const std::string & cmd2, const std::vector & params) +{ + std::string param_str; + std::string change_nt_cmd; + param_str.clear(); + change_nt_cmd.clear(); + change_nt_cmd = cmd1; + // prepare parameters + for (const auto & pp : params) + { + param_str += std::to_string(pp) + " "; + change_nt_cmd += std::to_string(pp) + " mjf, "; + } + + change_nt_cmd.erase(change_nt_cmd.end() - 2); + change_nt_cmd += cmd2; + system(change_nt_cmd.data()); + + return param_str; } -int64_t exactNumber() { - std::ifstream ifs("tmp.log"); - if (!ifs.is_open()) { - std::cout << "error opening tmp.log"; - assert(false); - } +int64_t +exactNumber() +{ + std::ifstream ifs("tmp.log"); + if (!ifs.is_open()) + { + std::cout << "error opening tmp.log"; + assert(false); + } - // process - std::string line; - std::getline(ifs, line); - auto it = std::remove_if(line.begin(), line.end(), [](const char &c){ - return !std::isdigit(c); - }); + // process + std::string line; + std::getline(ifs, line); + auto it = std::remove_if(line.begin(), line.end(), [](const char & c) { + return !std::isdigit(c); + }); - line.erase(it, line.end()); + line.erase(it, line.end()); - ifs.close(); + ifs.close(); - char* pEnd; + char * pEnd; - return std::strtol(line.data(), &pEnd, 10); + return std::strtol(line.data(), &pEnd, 10); } -int64_t getIrLines() { - std::string cmd = "wc -l out.ll 2>&1 | tee tmp.log"; - system(cmd.data()); +int64_t +getIrLines() +{ + std::string cmd = "wc -l out.ll 2>&1 | tee tmp.log"; + system(cmd.data()); - return exactNumber(); + return exactNumber(); } -int64_t getLibSize() { - std::string cmd = "wc -c libout.a 2>&1 | tee tmp.log"; - system(cmd.data()); +int64_t +getLibSize() +{ + std::string cmd = "wc -c libout.a 2>&1 | tee tmp.log"; + system(cmd.data()); - return exactNumber(); + return exactNumber(); } struct perfData { - int64_t inst_count_avg; - int64_t time_consumption_avg; - int64_t ir_lines; - int64_t library_size; + int64_t inst_count_avg; + int64_t time_consumption_avg; + int64_t ir_lines; + int64_t library_size; }; -struct perfData recordData(const std::string& test_cases, const std::string& param_str, std::ofstream& ofs) { - const size_t iteration_num = 5; - - perfData perf_data = {0, 0, 0, 0}; - - for (size_t idx = 0; idx < iteration_num; idx++) { - const std::pair inst_time_data = processData(test_cases, param_str); - perf_data.inst_count_avg += (inst_time_data.first/1000); - perf_data.time_consumption_avg += (inst_time_data.second/1000); - } - perf_data.inst_count_avg /= iteration_num; - perf_data.time_consumption_avg /= iteration_num; - - perf_data.ir_lines = getIrLines(); - perf_data.library_size = getLibSize(); - - ofs << test_cases << "\t" << param_str << "\t" << perf_data.inst_count_avg - << "\t" << perf_data.time_consumption_avg << "\t" << perf_data.ir_lines << "\t" << perf_data.library_size << std::endl; - - return perf_data; +struct perfData +recordData(const std::string & test_cases, const std::string & param_str, std::ofstream & ofs) +{ +#ifdef DEBUG_TS + const size_t iteration_num = 1; +#else + const size_t iteration_num = 5; +#endif + + perfData perf_data = {0, 0, 0, 0}; + + for (size_t idx = 0; idx < iteration_num; idx++) + { + const std::pair inst_time_data = processData(test_cases, param_str); + perf_data.inst_count_avg += (inst_time_data.first / 1000); + perf_data.time_consumption_avg += (inst_time_data.second / 1000); + } + perf_data.inst_count_avg /= iteration_num; + perf_data.time_consumption_avg /= iteration_num; + + perf_data.ir_lines = getIrLines(); + perf_data.library_size = getLibSize(); + + ofs << test_cases << "\t" << param_str << "\t" << perf_data.inst_count_avg + << "\t" << perf_data.time_consumption_avg << "\t" << perf_data.ir_lines << "\t" << perf_data.library_size << std::endl; + + return perf_data; } -int main(int argc, char** argv) { - std::vector test_cases{ - "perf_exp", "perf_log", - "perf_acosh", "perf_j0", - "perf_y0", "perf_rem_pio2", "perf_sincosf", - "perf_float64_add", "perf_float64_div", - "perf_float64_mul"}; - - if (argc >= 2) { - test_cases.clear(); - test_cases.emplace_back(argv[1]); - } - - std::ofstream ofs("perf.log"); - if (!ofs.is_open()) { - std::cout << "error opening perf.log"; - return -1; - } - - std::ofstream avg_speedup("average_speedup.log"); - if (!avg_speedup.is_open()) { - std::cout << "error opening perf.log"; - return -1; - } - - std::vector> normalParameters{ - {-1000.3, -999.2}, - {-134.5, -133.8}, - {-23.9, -23.1}, - {-5.4, -4.5}, - {-0.9, -0.4}, - {0.2, 0.8}, - {9.7, 10.5}, - {35.75, 36.03}, - {476.84, 477.21}, - {999.8, 1000.9} - }; - - std::vector range_extend{1, 10, 100, 1000, 10000, 100000}; - - if (argc == 3) { - range_extend.clear(); - range_extend.emplace_back(strtod(argv[2], nullptr)); - } - - std::vector> trigonometricParams{ - {0, 0.17453292519943295}, // (0, pi/18) - {0.6981317007977318, 0.8726646259971648}, // (2pi/9, 5pi/18) - {1.3962634015954636, 1.5707963267948966}, // (4pi/9, pi/2) - {2.0943951023931953, 2.2689280275926285}, // (2pi/3, 13pi/18) - {2.792526803190927, 2.9670597283903604}, // (8pi/9, 17pi/18) - {3.490658503988659, 3.665191429188092}, // (10pi/9, 7pi/6) - {4.1887902047863905, 4.363323129985824}, // (8pi/6, 25pi/18) - {4.886921905584122, 5.061454830783556}, // (14pi/9, 29pi/18) - {5.585053606381854, 5.759586531581288}, // (16pi/9, 33pi/18) - {5.934119456780721, 6.1086523819801535} // (17pi/9, 35pi/18) - }; - - if (argc == 4) { - normalParameters.clear(); - std::vector input_param{strtod(argv[2], nullptr), strtod(argv[3], nullptr)}; - normalParameters.emplace_back(input_param); - - trigonometricParams.clear(); - trigonometricParams.emplace_back(input_param); - } - - ofs << "test case\tparam\tinstruction count\ttime consumption\tir lines\tlibrary size" << std::endl; - avg_speedup << "test cast\textend\tinstruction count\ttime consumption\tir lines\tlibrary size" << std::endl; - - for (size_t case_id = 0; case_id < test_cases.size(); case_id++) { - int avg_inst_speedup = 0; - int avg_time_speedup = 0; - int avg_ir_reduce = 0; - int avg_lib_size_reduce = 0; - const std::vector> parameters = - test_cases[case_id] == "perf_float64_sin" ? trigonometricParams : normalParameters; - for (const auto& extend : range_extend) { - for (const auto& p : parameters) { - const std::string param_str = change_nt_range("sed -i 's/3 mjf, 10 mjf/", - "/g' ../../sensors/test.nt", - {p.front(), p.back()-1+extend}); - const double p1 = p.front() + 0.6; - const double p2 = p.back() + 0.3; - change_nt_range("sed -i 's/1 mjf, 16 mjf/", "/g' ../../sensors/test.nt", {p1, p2-1+extend}); - - perfData ori_perf_data = recordData(test_cases[case_id], param_str, ofs); - perfData opt_perf_data = recordData(test_cases[case_id] + "_opt", param_str, ofs); - - int inst_speedup = round((ori_perf_data.inst_count_avg - opt_perf_data.inst_count_avg) * 100 / opt_perf_data.inst_count_avg); - int time_speedup = round((ori_perf_data.time_consumption_avg - opt_perf_data.time_consumption_avg) * 100 / opt_perf_data.time_consumption_avg); - int ir_reduce = round((ori_perf_data.ir_lines - opt_perf_data.ir_lines) * 100 / opt_perf_data.ir_lines); - int lib_size_reduce = round((ori_perf_data.library_size - opt_perf_data.library_size) * 100 / opt_perf_data.library_size); - ofs << "speed up after optimization\t" << param_str << "\t" << inst_speedup << "%\t" << time_speedup << "%\t" - << ir_reduce << "%\t" << lib_size_reduce << "%" << std::endl; - - avg_inst_speedup += inst_speedup; - avg_time_speedup += time_speedup; - avg_ir_reduce += ir_reduce; - avg_lib_size_reduce += lib_size_reduce; - - // reset test.nt - change_nt_range("sed -i 's/", "/3 mjf, 10 mjf/g' ../../sensors/test.nt", - {p.front(), p.back()-1+extend}); - change_nt_range("sed -i 's/", "/1 mjf, 16 mjf/g' ../../sensors/test.nt", {p1, p2-1+extend}); - } - avg_inst_speedup = round(avg_inst_speedup / parameters.size()); - avg_time_speedup = round(avg_time_speedup / parameters.size()); - avg_ir_reduce = round(avg_ir_reduce / parameters.size()); - avg_lib_size_reduce = round(avg_lib_size_reduce / parameters.size()); - avg_speedup << test_cases[case_id] << "\t" << extend << "\t" << avg_inst_speedup << "%\t" - << avg_time_speedup << "%\t" << avg_ir_reduce << "%\t" << avg_lib_size_reduce << "%" << std::endl; - - if (test_cases[case_id] == "perf_float64_sin") { - // trigonometricParams cannot have extend - break; - } - } - } - - ofs.close(); - - return 0; +int +main(int argc, char ** argv) +{ + std::vector test_cases{ + "perf_exp", "perf_log", + "perf_acosh", "perf_j0", + "perf_y0", "perf_rem_pio2", "perf_sincosf", + "perf_float64_add", "perf_float64_div", + "perf_float64_mul"}; + + if (argc >= 2) + { + test_cases.clear(); + test_cases.emplace_back(argv[1]); + } + + std::ofstream ofs("perf.log"); + if (!ofs.is_open()) + { + std::cout << "error opening perf.log"; + return -1; + } + + std::ofstream avg_speedup("average_speedup.log"); + if (!avg_speedup.is_open()) + { + std::cout << "error opening perf.log"; + return -1; + } + +#ifdef DEBUG_TS + std::vector> normalParameters{ + {0.2, 0.8}, + }; + std::vector range_extend{1}; +#else + std::vector> normalParameters{ + {-1000.3, -999.2}, + {-134.5, -133.8}, + {-23.9, -23.1}, + {-5.4, -4.5}, + {-0.9, -0.4}, + {0.2, 0.8}, + {9.7, 10.5}, + {35.75, 36.03}, + {476.84, 477.21}, + {999.8, 1000.9}}; + std::vector range_extend{1, 10, 100, 1000, 10000, 100000}; +#endif + + if (argc == 3) + { + range_extend.clear(); + range_extend.emplace_back(strtod(argv[2], nullptr)); + } + + std::vector> trigonometricParams{ + {0, 0.17453292519943295}, // (0, pi/18) + {0.6981317007977318, 0.8726646259971648}, // (2pi/9, 5pi/18) + {1.3962634015954636, 1.5707963267948966}, // (4pi/9, pi/2) + {2.0943951023931953, 2.2689280275926285}, // (2pi/3, 13pi/18) + {2.792526803190927, 2.9670597283903604}, // (8pi/9, 17pi/18) + {3.490658503988659, 3.665191429188092}, // (10pi/9, 7pi/6) + {4.1887902047863905, 4.363323129985824}, // (8pi/6, 25pi/18) + {4.886921905584122, 5.061454830783556}, // (14pi/9, 29pi/18) + {5.585053606381854, 5.759586531581288}, // (16pi/9, 33pi/18) + {5.934119456780721, 6.1086523819801535} // (17pi/9, 35pi/18) + }; + + if (argc == 4) + { + normalParameters.clear(); + std::vector input_param{strtod(argv[2], nullptr), strtod(argv[3], nullptr)}; + normalParameters.emplace_back(input_param); + + trigonometricParams.clear(); + trigonometricParams.emplace_back(input_param); + } + + ofs << "test case\tparam\tinstruction count\ttime consumption\tir lines\tlibrary size" << std::endl; + avg_speedup << "test cast\textend\tinstruction count\ttime consumption\tir lines\tlibrary size" << std::endl; + + for (size_t case_id = 0; case_id < test_cases.size(); case_id++) + { + int avg_inst_speedup = 0; + int avg_time_speedup = 0; + int avg_ir_reduce = 0; + int avg_lib_size_reduce = 0; + const std::vector> parameters = + test_cases[case_id] == "perf_float64_sin" ? trigonometricParams : normalParameters; + for (const auto & extend : range_extend) + { + for (const auto & p : parameters) + { + const std::string param_str = change_nt_range("sed -i 's/3 mjf, 10 mjf/", + "/g' ../../sensors/test.nt", + {p.front(), p.back() - 1 + extend}); + const double p1 = p.front() + 0.6; + const double p2 = p.back() + 0.3; + change_nt_range("sed -i 's/1 mjf, 16 mjf/", "/g' ../../sensors/test.nt", {p1, p2 - 1 + extend}); + + perfData ori_perf_data = recordData(test_cases[case_id], param_str, ofs); + perfData opt_perf_data = recordData(test_cases[case_id] + "_opt", param_str, ofs); + + int inst_speedup = round((ori_perf_data.inst_count_avg - opt_perf_data.inst_count_avg) * 100 / opt_perf_data.inst_count_avg); + int time_speedup = round((ori_perf_data.time_consumption_avg - opt_perf_data.time_consumption_avg) * 100 / opt_perf_data.time_consumption_avg); + int ir_reduce = round((ori_perf_data.ir_lines - opt_perf_data.ir_lines) * 100 / opt_perf_data.ir_lines); + int lib_size_reduce = round((ori_perf_data.library_size - opt_perf_data.library_size) * 100 / opt_perf_data.library_size); + ofs << "speed up after optimization\t" << param_str << "\t" << inst_speedup << "%\t" << time_speedup << "%\t" + << ir_reduce << "%\t" << lib_size_reduce << "%" << std::endl; + + avg_inst_speedup += inst_speedup; + avg_time_speedup += time_speedup; + avg_ir_reduce += ir_reduce; + avg_lib_size_reduce += lib_size_reduce; + + // reset test.nt + change_nt_range("sed -i 's/", "/3 mjf, 10 mjf/g' ../../sensors/test.nt", + {p.front(), p.back() - 1 + extend}); + change_nt_range("sed -i 's/", "/1 mjf, 16 mjf/g' ../../sensors/test.nt", {p1, p2 - 1 + extend}); + } + avg_inst_speedup = round(avg_inst_speedup / parameters.size()); + avg_time_speedup = round(avg_time_speedup / parameters.size()); + avg_ir_reduce = round(avg_ir_reduce / parameters.size()); + avg_lib_size_reduce = round(avg_lib_size_reduce / parameters.size()); + avg_speedup << test_cases[case_id] << "\t" << extend << "\t" << avg_inst_speedup << "%\t" + << avg_time_speedup << "%\t" << avg_ir_reduce << "%\t" << avg_lib_size_reduce << "%" << std::endl; + + if (test_cases[case_id] == "perf_float64_sin") + { + // trigonometricParams cannot have extend + break; + } + } + } + + ofs.close(); + + return 0; } diff --git a/src/newton/newton-irPass-LLVMIR-optimizeByRange.cpp b/src/newton/newton-irPass-LLVMIR-optimizeByRange.cpp index 0ddc69bc5..ad0ecbad3 100644 --- a/src/newton/newton-irPass-LLVMIR-optimizeByRange.cpp +++ b/src/newton/newton-irPass-LLVMIR-optimizeByRange.cpp @@ -390,6 +390,7 @@ irPassLLVMIROptimizeByRange(State * N) assert(false); } } + flexprint(N->Fe, N->Fm, N->Fpinfo, "shrink data type by range\n"); // flexprint(N->Fe, N->Fm, N->Fpinfo, "shrink data type by range\n"); // for (auto & mi : *Mod) diff --git a/src/newton/newton-irPass-LLVMIR-rangeAnalysis.h b/src/newton/newton-irPass-LLVMIR-rangeAnalysis.h index e8631d06f..0f61f595b 100644 --- a/src/newton/newton-irPass-LLVMIR-rangeAnalysis.h +++ b/src/newton/newton-irPass-LLVMIR-rangeAnalysis.h @@ -44,6 +44,7 @@ #include #include #include +#include #include #include #include diff --git a/src/newton/newton-irPass-LLVMIR-shrinkTypeByRange.cpp b/src/newton/newton-irPass-LLVMIR-shrinkTypeByRange.cpp index 96ce7a222..d6a7ec9ac 100644 --- a/src/newton/newton-irPass-LLVMIR-shrinkTypeByRange.cpp +++ b/src/newton/newton-irPass-LLVMIR-shrinkTypeByRange.cpp @@ -92,11 +92,13 @@ varType getFloatingTypeEnum(double min, double max) { varType finalType; - if ((std::abs(min) < FLT_MAX) && (std::abs(max) < FLT_MAX)) + if ((FLT_EPSILON < std::abs(min) && std::abs(min) < FLT_MAX) && + (FLT_EPSILON < std::abs(max) && std::abs(max) < FLT_MAX)) { finalType = FLOAT; } - else if ((std::abs(min) < DBL_MAX) && (std::abs(max) < DBL_MAX)) + else if ((DBL_EPSILON < std::abs(min) && std::abs(min) < DBL_MAX) && + (DBL_EPSILON < std::abs(max) && std::abs(max) < DBL_MAX)) { finalType = DOUBLE; } @@ -245,7 +247,7 @@ getTypeInfo(State * N, Value * inValue, switch (inInstType->getTypeID()) { case Type::IntegerTyID: - typeInformation = getShrinkIntType(N, inValue, vrRangeIt->second); + typeInformation = getShrinkIntType(N, inValue, vrRangeIt->second); break; case Type::FloatTyID: break; @@ -925,6 +927,11 @@ matchDestType(State * N, Instruction * inInstruction, BasicBlock & llvmIrBasicBl typeInfo backType; backType.signFlag = isSignedValue(inInstruction); backType.valueType = inInstType; + if (isa(inInstruction)) + { + unsigned ptAddressSpace = srcType->getPointerAddressSpace(); + backType.valueType = backType.valueType->getPointerTo(ptAddressSpace); + } for (size_t id = 0; id < inInstruction->getNumOperands(); id++) { auto newTypeValue = rollbackType(N, inInstruction, id, llvmIrBasicBlock, typeChangedInst, backType); @@ -974,7 +981,13 @@ matchDestType(State * N, Instruction * inInstruction, BasicBlock & llvmIrBasicBl /* * roll back operands to typeInformation.valueType * */ - for (size_t id = 0; id < inInstruction->getNumOperands(); id++) + if (isa(inInstruction)) + { + unsigned ptAddressSpace = srcType->getPointerAddressSpace(); + typeInformation.valueType = typeInformation.valueType->getPointerTo(ptAddressSpace); + } + size_t roll_backed_op_num = isa(inInstruction) ? 1 : inInstruction->getNumOperands(); + for (size_t id = 0; id < roll_backed_op_num; id++) { typeInfo operandPrevTypeInfo{typeInformation.valueType, isSignedValue(inInstruction->getOperand(id))}; @@ -1496,6 +1509,10 @@ mergeCast(State * N, Function & llvmIrFunction, Instruction * llvmIrInstruction = &*itBB++; switch (llvmIrInstruction->getOpcode()) { + case Instruction::FPToUI: + case Instruction::FPToSI: + case Instruction::SIToFP: + case Instruction::UIToFP: case Instruction::ZExt: case Instruction::SExt: case Instruction::FPExt: @@ -1540,7 +1557,23 @@ mergeCast(State * N, Function & llvmIrFunction, * */ Value * castInst; auto valueType = llvmIrInstruction->getType(); - if (valueType->isIntegerTy()) + if ((valueType->isFloatTy() || valueType->isDoubleTy()) && + sourceOperand->getType()->isIntegerTy()) + { + // float fa = (float)ia; + bool isSinged = sourceInst->getOpcode() == Instruction::SIToFP; + castInst = isSinged ? Builder.CreateSIToFP(sourceOperand, valueType) + : Builder.CreateUIToFP(sourceOperand, valueType); + } + else if (valueType->isIntegerTy() && + (sourceOperand->getType()->isFloatTy() || sourceOperand->getType()->isDoubleTy())) + { + // int iq = (int)fq; + bool isSinged = sourceInst->getOpcode() == Instruction::FPToSI; + castInst = isSinged ? Builder.CreateFPToSI(sourceOperand, valueType) + : Builder.CreateFPToUI(sourceOperand, valueType); + } + else if (valueType->isIntegerTy()) { castInst = Builder.CreateIntCast(sourceOperand, valueType, llvmIrInstruction->getOpcode() == Instruction::SExt); @@ -1648,6 +1681,10 @@ countCastInst(State * N, Function & llvmIrFunction) { switch (llvmIrInstruction.getOpcode()) { + case Instruction::FPToUI: + case Instruction::FPToSI: + case Instruction::SIToFP: + case Instruction::UIToFP: case Instruction::ZExt: case Instruction::SExt: case Instruction::FPExt: @@ -1827,19 +1864,7 @@ shrinkType(State * N, BoundInfo * boundInfo, Function & llvmIrFunction) * 1. construct instruction dependency link * 2. work with roll back strategies * */ - std::vector> prevDepLink = getDependencyLink(N, llvmIrFunction); - std::map typeChangedInst = shrinkInstType(N, boundInfo, llvmIrFunction); - mergeCast(N, llvmIrFunction, boundInfo->virtualRegisterRange, typeChangedInst); - std::vector> newDepLink = getDependencyLink(N, llvmIrFunction); - - for (auto & depLink : newDepLink) - { - if (rollBackStrategy(N, depLink)) - { - rollBackDependencyLink(N, depLink, boundInfo->virtualRegisterRange, typeChangedInst); - } - } - + std::map typeChangedInst = shrinkInstType(N, boundInfo, llvmIrFunction); mergeCast(N, llvmIrFunction, boundInfo->virtualRegisterRange, typeChangedInst); } -} \ No newline at end of file +}