Differences

This shows you the differences between two versions of the page.

--- notes:comporg:projects:pnc2 [2018/02/07 23:39] – [Matthew Chon pnc2 Data Visualization (February 6th, 2018):] bschulte
+++ notes:comporg:projects:pnc2 [2018/02/11 16:50] (current) – [Benjamin Schultes PNC1:] wedge
@@ Line 172: / Line 172: @@
 As shown in the graph and chart, the C implemented pncs destroyed the other languages in runtime. Compiling with gccO3 gave the best performance in terms of runtime performance. It can be concluded that the lower-level language outperformed the higher-level languages in terms of runtime and qty.
-===Benjamin Schultes PNC1: ===
+====Benjamin Schultes PNC1:====
+===All Scripts===
+{{:notes:comporg:projects:bschulte1.png?400|}}
+{{:notes:comporg:projects:bschulte2.png?400|}}
+{{:notes:comporg:projects:bschulte3.png?400|}}
+{{:notes:comporg:projects:bschulte4.png?400|}}
+As expected, the C programs outperformed all other scripts. There isn't a lot of data shown on the chart because many of the C programs had very similar run times.
+<code>
+qty	bash	gcc	gccO0	gccO1	gccO2	gccO3	gccOs	go	lua	python3	ruby
+	1.018	0	0	0	0	0	0	0	0	0.001	0
+		0	0	0	0	0	0	0	0.001	0.002	0.001
+		0	0	0	0	0	0	0	0.002	0.007	0.002
+		0	0	0	0	0	0	0.001	0.006	0.019	0.007
+		0.001	0.001	0.001	0.001	0.001	0.001	0.002	0.018	0.056	0.02
+		0.003	0.003	0.002	0.002	0.002	0.003	0.005	0.044	0.155	0.056
+		0.008	0.008	0.007	0.007	0.007	0.008	0.012	0.123	0.451	0.162
+		0.023	0.023	0.019	0.019	0.019	0.023	0.033	0.36		0.454
+		0.065	0.065	0.052	0.052	0.055	0.065	0.091	1.003		1.312
+		0.183	0.183	0.145	0.145	0.145	0.182	0.254
+		0.517	0.517	0.409	0.408	0.408	0.516	0.714
+				1.156	1.154	1.154
+</code>
+====Christian Cattell pnc2====
+{{:notes:comporg:projects:ccattellpnc2.png|}}
+<code>
+ qty
+          bash    g++     gcc     gccO0   gccO1   gccO2   gccO3   gccOs   js      perl    python
+================================================================================================
+   1.169   0.000   0.000   0.000   0.000   0.000   0.000   0.000   0.010   0.003   0.001
+   2.613   0.000   0.000   0.000   0.000   0.000   0.000   0.010   0.011   0.007   0.004
+   5.944   0.000   0.051   0.051   0.000   0.000   0.000   0.012   0.012   0.023   0.011
+   -----   0.059   0.061   0.061   0.008   0.016   0.008   0.021   0.014   0.092   0.023
+   -----   0.081   0.065   0.065   0.017   0.014   0.009   0.021   0.024   0.235   0.065
+   -----   0.121   0.071   0.071   0.034   0.031   0.013   0.032   0.032   1.020   0.182
+   -----   0.167   0.050   0.050   0.041   0.039   0.019   0.049   0.050   2.351   0.462
+   -----   0.201   0.089   0.089   0.049   0.041   0.027   0.061   0.094   -----   1.287
+   -----   0.347   0.122   0.122   0.071   0.059   0.041   0.069   0.256   -----   3.657
+   -----   0.602   0.319   0.319   0.196   0.197   0.193   0.209   0.534   -----   -----
+   -----   -----   0.783   0.783   0.544   0.531   0.496   0.512   0.879   -----   -----
+</code>
+==Thoughts==
+Bash is really, really bad actually. Makes you wonder just how much is really going on when you run it. I expect js to run the worst of the bunch (minus bash) so that surprised me. When making the C++ program, I somewhat tried to make it slow to see what kind of performance it would get so I am somewhat surprised by the results there. Seems like the C++ program could probably get pretty efficient when handled correctly.
+As for writing everything, it was actually not as bad as I thought it would be. Core concepts translate really well to other languages. It is interesting to see the differences in the languages, but they are seemingly just syntactical. This is just referring to the basic stuff like loops and conditionals etc. Probably start to see larger differences as you get to more advanced parts of a language.
+====Kris Beykirch (kbeykirc)====
+{{:notes:comporg:projects:kbeykirc.png|}}
+==Reflections==
+The first thing that has to be said is that bash is simply the worst: the lowest number of calculations that didn’t time out, and the bash curve is far, far to the left of everything else. Interestingly, next in line is python, the same language I used to create this graph. I didn’t have a lot of imports in my python code (no square root function, thanks to using the approximated square root trick instead), but if I were using it for something sophisticated like graphing with the matplotlib library, and had to do a lot of that in a program, I can imagine that it would be rather slow. I remember using python for heavy calculations back in my physics days, and waiting forever for something to execute (that being said, the scipy library that I used to do those calculations in the first place made it an invaluable tool for exactly what I used it for, even if it took a while).
+Next best after python is lua, and then ruby, which are all in a roughly comparable group. Go improves quite a bit timewise, and outstripping all are the C programs. itcc and tcc perform ever so slightly worse than the gcc variants, but compared to the distance between go and itcc/tcc, the distance between itcc/tcc and gcc are pretty minimal.
+General trend seems to be that the higher the language level, the worse the performance is. This makes sense, since there’s more overhead, and the language isn’t necessarily well designed for heavy computation (bash is certainly not made for this, a warning that I saw on a bash shell scripting guide and completely ignored for the purposes of this project).
+The trade-off, though, is that some of the higher-level languages looked far nicer than C did (bash being the exception), with the programs looking cleaner and probably more self-explanatory to somebody new to coding. They were also shorter… most of my C programs were around 90 to 100 lines long, most of the other programs a mere 50 to 60 lines. It’s not a huge difference here, but for longer programs the extra space spent on writing functions and generally doing things the “hard” way in C (not to mention the curly braces) could certainly add up. But when pnc1 performance is concerned, C is certainly much better than all of the other languages I used.
+====Kevin Todd (ktodd3)====
+For PNC1 I ended up using PrimeregB instead which gave some different results compared to the others who used Primeregbs
+{{:notes:comporg:projects:pnc2plot.png?|}}
+==Thoughts:==
+I was surprised by the results of my testing as Java and GO seemed to beat out the others, I expected the C++ to be the most efficient as it is a higher level language. Python was the least efficient which in hind sight isn't very surprising at it was rather easy to use would could mean it's a lower level language but it being 'easy' doesn't guarantee that it's a low level language. On the note of why C++ lost could be to a bunch of different factors; one reason it lost out may be due to how I coded the program in the other languages. I may have been able to unintentionally make the other code slightly more efficient while my original was lacking, however I don't think is the right answer as I tried to keep the code very similar and didn't have too much trouble to do so. Another idea as to why C lost out might be attributed to calculating, I used Primeregb which only breaks when it finds out it's not a prime, it does not use the square root trick. Maybe C++ is much more efficient at using the square-root in calculations and that is why when used it shines. Also the number of primes I reached were pretty low compared to other student's so C++ also didn't get a chance to show what it can do in longer term calculations.
+{{:notes:comporg:projects:pnc2plots.png?|}}

Lab46 Wiki

User Tools

Site Tools

Differences

Page Tools