{"id":1194,"date":"2010-09-07T13:37:24","date_gmt":"2010-09-07T11:37:24","guid":{"rendered":"http:\/\/oldblogs.uct.ac.za\/blog\/big-bytes\/2010\/09\/07\/c-vs-fortran"},"modified":"2022-09-26T19:55:33","modified_gmt":"2022-09-26T17:55:33","slug":"c-vs-fortran","status":"publish","type":"post","link":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/","title":{"rendered":"C vs Fortran"},"content":{"rendered":"Surprisingly, given the proliferation of C code, Fortran out-performs C in many areas.\u00a0 Fortran allows better numerical array manipulation, provides a rich set of highly optimized precision numeric functions making it more predictable and faster than C and also provides extremely efficient IO functionality.\r\n\r\nHowever something to keep in mind when writing Fortran applications or porting code is \"row versus column order\".\u00a0 Fortran and C differ in their methods of storing arrays in linear memory.\u00a0 Fortran uses column-major order (as does Matlab) while C uses row-major order.\u00a0 While there is no intrinsic benefit in either approach, a lack of undertsanding of row versus column ordering can lead to speed degredation.\u00a0 This is because the elements of the array that are being traversed in RAM are not contiguous when using the incorrect method and for very large arrays the data may not be cached.\u00a0 This is especially true for large higher dimension arrays.\r\n\r\nAs a simple example consider the 2 dimensional array:\r\n\r\n\r\n\"Array\"\r\n\r\nFortran would store the array in memory as follows:\r\n\r\n\"\"\r\n\r\nWhile C would store the array as follows:\r\n\r\n\"\"\r\n\r\nA programmer should take care when formulating \"for loops\" to ensure that the array traversal variables i and j are ordered correctly. For example the C code:\r\n\r\nfor (i=0; i<MAXi; i++) {\r\n for (j=0; j<MAXj; j++) {\r\n [arithmetic caculation on\u00a0 array[i][j]]\r\n }\r\n }<\/code>\r\n\r\n...is optimal as the primary array elements are addressed in \"row major order\" by the outer loop.\r\n\r\nThe graph below shows what happens when identical array computations are performed using the incorrect array adressing scheme (a lower number is better).\u00a0 The blue graph shows the time taken to complete a programm compiled in Fortran.\u00a0 Here column major addressing is clearly faster than row major.\u00a0 The red graph shows time taken to run the same code compiled in C.\u00a0 Here it is clear that the inverse is true, the column major scheme takes slightly longer to run than row major.\r\n\r\n\"C\r\n\r\nAdditionally, it can be seen that the Fortran code is significantly and\r\nconsistently faster than C.\u00a0 These tests were performed repeatedly and\r\nan average taken to avoid inconsistencies caused by data caching.\r\nAdditionally the tests were run using the OMP library to make use of\r\nmultiple processors.\u00a0 The findings were consistent and independent of the\r\nnumber of cores used.\u00a0 The ICTS cluster provides both GNU Fortran and C\r\ncompilers.","protected":false},"excerpt":{"rendered":"

Surprisingly, given the proliferation of C code, Fortran out-performs C in many areas.  Fortran allows better numerical array manipulation, provides a rich set of highly optimized precision numeric functions making it more predictable and faster than C and also provides extremely efficient IO functionality.<\/p>\n

However something to keep in mind when writing Fortran applications or porting code is “row versus column order”.  Fortran and C differ in their methods of storing arrays in linear memory.  Fortran uses column-major order (as does Matlab) while C uses row-major order.  While there is no intrinsic benefit in either approach, a lack of undertsanding of row versus column ordering can lead to speed degredation.  This is because the elements of the array that are being traversed in RAM are not contiguous when using the incorrect method and for very large arrays the data may not be cached.  This is especially true for large higher dimension arrays.<\/p>\n

As a simple example consider the 2 dimensional array:<\/p>\n

\"Array\"<\/p>\n

Fortran would store the array in memory as follows:<\/p>\n

<\/p>\n

While C would store the array as follows: <\/p>\n

<\/p>\n

A programmer should take care when formulating “for loops” to ensure that the array traversal variables i and j are ordered correctly. For example the C code:<\/p>\n

    for (i=0; i<MAXi; i++)
        {
        for (j=0; j<MAXj; j++)
            {
                [arithmetic caculation on  array[i][j]]          
            }
        }<\/p>\n

…is optimal as the primary array elements are addressed in “row major order” by the outer loop. <\/p>\n

The graph below shows what happens when identical array computations are performed using the incorrect array adressing scheme (a lower number is better).  The blue graph shows the time taken to complete a programm compiled in Fortran.  Here column major addressing is clearly faster than row major.  The red graph shows time taken to run the same code compiled in C.  Here it is clear that the inverse is true, the column major scheme takes slightly longer to run than row major.<\/p>\n

\"C<\/p>\n

Additionally, it can be seen that the Fortran code is significantly and
\nconsistently faster than C.  These tests were performed repeatedly and
\nan average taken to avoid inconsistencies caused by data caching. 
\nAdditionally the tests were run using the OMP library to make use of
\nmultiple processors.  The findings were consistent and independent of the
\nnumber of cores used.  The ICTS cluster provides both GNU Fortran and C
\ncompilers. <\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[10,8],"tags":[],"yoast_head":"\nC vs Fortran - UCT HPC<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"C vs Fortran - UCT HPC\" \/>\n<meta property=\"og:description\" content=\"Surprisingly, given the proliferation of C code, Fortran out-performs C in many areas.  Fortran allows better numerical array manipulation, provides a rich set of highly optimized precision numeric functions making it more predictable and faster than C and also provides extremely efficient IO functionality.However something to keep in mind when writing Fortran applications or porting code is "row versus column order".  Fortran and C differ in their methods of storing arrays in linear memory.  Fortran uses column-major order (as does Matlab) while C uses row-major order.  While there is no intrinsic benefit in either approach, a lack of undertsanding of row versus column ordering can lead to speed degredation.  This is because the elements of the array that are being traversed in RAM are not contiguous when using the incorrect method and for very large arrays the data may not be cached.  This is especially true for large higher dimension arrays.As a simple example consider the 2 dimensional array:Fortran would store the array in memory as follows:While C would store the array as follows: A programmer should take care when formulating "for loops" to ensure that the array traversal variables i and j are ordered correctly. For example the C code:    for (i=0; i<MAXi; i++)        {        for (j=0; j<MAXj; j++)            {                [arithmetic caculation on  array[i][j]]                      }        }...is optimal as the primary array elements are addressed in "row major order" by the outer loop. The graph below shows what happens when identical array computations are performed using the incorrect array adressing scheme (a lower number is better).  The blue graph shows the time taken to complete a programm compiled in Fortran.  Here column major addressing is clearly faster than row major.  The red graph shows time taken to run the same code compiled in C.  Here it is clear that the inverse is true, the column major scheme takes slightly longer to run than row major.Additionally, it can be seen that the Fortran code is significantly and consistently faster than C.  These tests were performed repeatedly and an average taken to avoid inconsistencies caused by data caching.  Additionally the tests were run using the OMP library to make use of multiple processors.  The findings were consistent and independent of the number of cores used.  The ICTS cluster provides both GNU Fortran and C compilers.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\" \/>\n<meta property=\"og:site_name\" content=\"UCT HPC\" \/>\n<meta property=\"article:published_time\" content=\"2010-09-07T11:37:24+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-09-26T17:55:33+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ucthpc.uct.ac.za\/wp-content\/uploads\/2015\/07\/Array.png\" \/>\n<meta name=\"author\" content=\"Andrew Lewis\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andrew Lewis\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"2 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\"},\"author\":{\"name\":\"Andrew Lewis\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#\/schema\/person\/c183ad1c0a1063124a72d63963ae9c7e\"},\"headline\":\"C vs Fortran\",\"datePublished\":\"2010-09-07T11:37:24+00:00\",\"dateModified\":\"2022-09-26T17:55:33+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\"},\"wordCount\":375,\"publisher\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#organization\"},\"articleSection\":[\"MPI\",\"programming\"],\"inLanguage\":\"en-ZA\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\",\"url\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\",\"name\":\"C vs Fortran - UCT HPC\",\"isPartOf\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#website\"},\"datePublished\":\"2010-09-07T11:37:24+00:00\",\"dateModified\":\"2022-09-26T17:55:33+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/#breadcrumb\"},\"inLanguage\":\"en-ZA\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/ucthpc.uct.ac.za\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"C vs Fortran\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#website\",\"url\":\"https:\/\/ucthpc.uct.ac.za\/\",\"name\":\"UCT HPC\",\"description\":\"University of Cape Town High Performance Computing\",\"publisher\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/ucthpc.uct.ac.za\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-ZA\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#organization\",\"name\":\"University of Cape Town High Performance Computing\",\"url\":\"https:\/\/ucthpc.uct.ac.za\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-ZA\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/ucthpc.uct.ac.za\/wp-content\/uploads\/2015\/09\/logocircless.png\",\"contentUrl\":\"https:\/\/ucthpc.uct.ac.za\/wp-content\/uploads\/2015\/09\/logocircless.png\",\"width\":450,\"height\":423,\"caption\":\"University of Cape Town High Performance Computing\"},\"image\":{\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#\/schema\/person\/c183ad1c0a1063124a72d63963ae9c7e\",\"name\":\"Andrew Lewis\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-ZA\",\"@id\":\"https:\/\/ucthpc.uct.ac.za\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/9652c9c73beeab594b8dc2383a880048?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/9652c9c73beeab594b8dc2383a880048?s=96&d=mm&r=g\",\"caption\":\"Andrew Lewis\"},\"sameAs\":[\"http:\/\/blogs.uct.ac.za\/blog\/big-bytes\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"C vs Fortran - UCT HPC","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/","og_locale":"en_US","og_type":"article","og_title":"C vs Fortran - UCT HPC","og_description":"Surprisingly, given the proliferation of C code, Fortran out-performs C in many areas.  Fortran allows better numerical array manipulation, provides a rich set of highly optimized precision numeric functions making it more predictable and faster than C and also provides extremely efficient IO functionality.However something to keep in mind when writing Fortran applications or porting code is \"row versus column order\".  Fortran and C differ in their methods of storing arrays in linear memory.  Fortran uses column-major order (as does Matlab) while C uses row-major order.  While there is no intrinsic benefit in either approach, a lack of undertsanding of row versus column ordering can lead to speed degredation.  This is because the elements of the array that are being traversed in RAM are not contiguous when using the incorrect method and for very large arrays the data may not be cached.  This is especially true for large higher dimension arrays.As a simple example consider the 2 dimensional array:Fortran would store the array in memory as follows:While C would store the array as follows: A programmer should take care when formulating \"for loops\" to ensure that the array traversal variables i and j are ordered correctly. For example the C code:    for (i=0; i<MAXi; i++)        {        for (j=0; j<MAXj; j++)            {                [arithmetic caculation on  array[i][j]]                      }        }...is optimal as the primary array elements are addressed in \"row major order\" by the outer loop. The graph below shows what happens when identical array computations are performed using the incorrect array adressing scheme (a lower number is better).  The blue graph shows the time taken to complete a programm compiled in Fortran.  Here column major addressing is clearly faster than row major.  The red graph shows time taken to run the same code compiled in C.  Here it is clear that the inverse is true, the column major scheme takes slightly longer to run than row major.Additionally, it can be seen that the Fortran code is significantly and consistently faster than C.  These tests were performed repeatedly and an average taken to avoid inconsistencies caused by data caching.  Additionally the tests were run using the OMP library to make use of multiple processors.  The findings were consistent and independent of the number of cores used.  The ICTS cluster provides both GNU Fortran and C compilers.","og_url":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/","og_site_name":"UCT HPC","article_published_time":"2010-09-07T11:37:24+00:00","article_modified_time":"2022-09-26T17:55:33+00:00","og_image":[{"url":"https:\/\/ucthpc.uct.ac.za\/wp-content\/uploads\/2015\/07\/Array.png"}],"author":"Andrew Lewis","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Andrew Lewis","Est. reading time":"2 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/#article","isPartOf":{"@id":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/"},"author":{"name":"Andrew Lewis","@id":"https:\/\/ucthpc.uct.ac.za\/#\/schema\/person\/c183ad1c0a1063124a72d63963ae9c7e"},"headline":"C vs Fortran","datePublished":"2010-09-07T11:37:24+00:00","dateModified":"2022-09-26T17:55:33+00:00","mainEntityOfPage":{"@id":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/"},"wordCount":375,"publisher":{"@id":"https:\/\/ucthpc.uct.ac.za\/#organization"},"articleSection":["MPI","programming"],"inLanguage":"en-ZA"},{"@type":"WebPage","@id":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/","url":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/","name":"C vs Fortran - UCT HPC","isPartOf":{"@id":"https:\/\/ucthpc.uct.ac.za\/#website"},"datePublished":"2010-09-07T11:37:24+00:00","dateModified":"2022-09-26T17:55:33+00:00","breadcrumb":{"@id":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/#breadcrumb"},"inLanguage":"en-ZA","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/ucthpc.uct.ac.za\/index.php\/2010\/09\/07\/c-vs-fortran\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/ucthpc.uct.ac.za\/"},{"@type":"ListItem","position":2,"name":"C vs Fortran"}]},{"@type":"WebSite","@id":"https:\/\/ucthpc.uct.ac.za\/#website","url":"https:\/\/ucthpc.uct.ac.za\/","name":"UCT HPC","description":"University of Cape Town High Performance Computing","publisher":{"@id":"https:\/\/ucthpc.uct.ac.za\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ucthpc.uct.ac.za\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-ZA"},{"@type":"Organization","@id":"https:\/\/ucthpc.uct.ac.za\/#organization","name":"University of Cape Town High Performance Computing","url":"https:\/\/ucthpc.uct.ac.za\/","logo":{"@type":"ImageObject","inLanguage":"en-ZA","@id":"https:\/\/ucthpc.uct.ac.za\/#\/schema\/logo\/image\/","url":"https:\/\/ucthpc.uct.ac.za\/wp-content\/uploads\/2015\/09\/logocircless.png","contentUrl":"https:\/\/ucthpc.uct.ac.za\/wp-content\/uploads\/2015\/09\/logocircless.png","width":450,"height":423,"caption":"University of Cape Town High Performance Computing"},"image":{"@id":"https:\/\/ucthpc.uct.ac.za\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ucthpc.uct.ac.za\/#\/schema\/person\/c183ad1c0a1063124a72d63963ae9c7e","name":"Andrew Lewis","image":{"@type":"ImageObject","inLanguage":"en-ZA","@id":"https:\/\/ucthpc.uct.ac.za\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/9652c9c73beeab594b8dc2383a880048?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/9652c9c73beeab594b8dc2383a880048?s=96&d=mm&r=g","caption":"Andrew Lewis"},"sameAs":["http:\/\/blogs.uct.ac.za\/blog\/big-bytes"]}]}},"_links":{"self":[{"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/posts\/1194"}],"collection":[{"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/comments?post=1194"}],"version-history":[{"count":6,"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/posts\/1194\/revisions"}],"predecessor-version":[{"id":4274,"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/posts\/1194\/revisions\/4274"}],"wp:attachment":[{"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/media?parent=1194"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/categories?post=1194"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ucthpc.uct.ac.za\/index.php\/wp-json\/wp\/v2\/tags?post=1194"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}