[{"data":1,"prerenderedAt":702},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon02-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon02-f":515,"sidebar-sei-cert-fortran-coding-standard":524},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":30,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24,27],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard\u002F",{"title":25,"path":26},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":28,"path":29},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":32,"title":33,"body":34,"description":44,"extension":509,"meta":510,"navigation":7,"path":511,"seo":512,"stem":513,"__hash__":514},"content\u002F9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F3.con02-f.md","CON02-F. Protect reduction variables in multithreaded code",{"type":35,"value":36,"toc":502},"minimark",[37,41,45,48,68,73,84,188,192,198,268,275,355,359,362,424,427,431,442,464,468,498],[38,39,33],"h1",{"id":40},"con02-f-protect-reduction-variables-in-multithreaded-code",[42,43,44],"p",{},"Programmers should protect shared variables used in reduction operations using synchronization techniques or parallel construct clauses to prevent data races.",[42,46,47],{},"A reduction combines multiple values into a single result using a mathematical operation (e.g., addition, multiplication, logical AND\u002FOR). When executed in parallel, a reduction on a shared variable is typically implemented as a compound operation: read the current value, modify it, and write it back. Without proper protection, multiple threads can simultaneously read and update the variable, causing lost updates and undefined behavior.",[42,49,50,51,55,56,59,60,63,64,67],{},"In Fortran, reductions can be safely handled by OpenMP directives (such as ",[52,53,54],"code",{},"reduction"," clause or ",[52,57,58],{},"atomic"," updates) or Fortran standard features like the ",[52,61,62],{},"reduce"," locality specifier in ",[52,65,66],{},"do concurrent"," constructs or atomic subroutines.",[69,70,72],"h2",{"id":71},"noncompliant-code-example","Noncompliant Code Example",[42,74,75,76,79,80,83],{},"In this noncompliant example, the variable ",[52,77,78],{},"total_sum"," is ",[52,81,82],{},"shared"," among multiple threads. Because there is no protection for the addition operation, the read-modify-write sequence is non-atomic, leading to a data race and unpredictable final result.",[85,86,88],"code-block",{"quality":87},"bad",[89,90,95],"pre",{"className":91,"code":92,"language":93,"meta":94,"style":94},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","subroutine calculate_sum(array)\n  implicit none\n  integer, intent(in) :: array(:)\n  integer             :: i, total_sum\n\n  total_sum = 0\n  ! Noncompliant: total_sum is shared without protection\n  !$omp parallel do default(none) private(i) shared(array, total_sum)\n  do i = 1, size(array)\n    total_sum = total_sum + array(i)\n  end do\n  !$omp end parallel do\n\n  print *, \"Sum is: \", total_sum\nend subroutine\n","fortran","",[52,96,97,105,111,117,123,129,135,141,147,153,159,165,171,176,182],{"__ignoreMap":94},[98,99,102],"span",{"class":100,"line":101},"line",1,[98,103,104],{},"subroutine calculate_sum(array)\n",[98,106,108],{"class":100,"line":107},2,[98,109,110],{},"  implicit none\n",[98,112,114],{"class":100,"line":113},3,[98,115,116],{},"  integer, intent(in) :: array(:)\n",[98,118,120],{"class":100,"line":119},4,[98,121,122],{},"  integer             :: i, total_sum\n",[98,124,126],{"class":100,"line":125},5,[98,127,128],{"emptyLinePlaceholder":7},"\n",[98,130,132],{"class":100,"line":131},6,[98,133,134],{},"  total_sum = 0\n",[98,136,138],{"class":100,"line":137},7,[98,139,140],{},"  ! Noncompliant: total_sum is shared without protection\n",[98,142,144],{"class":100,"line":143},8,[98,145,146],{},"  !$omp parallel do default(none) private(i) shared(array, total_sum)\n",[98,148,150],{"class":100,"line":149},9,[98,151,152],{},"  do i = 1, size(array)\n",[98,154,156],{"class":100,"line":155},10,[98,157,158],{},"    total_sum = total_sum + array(i)\n",[98,160,162],{"class":100,"line":161},11,[98,163,164],{},"  end do\n",[98,166,168],{"class":100,"line":167},12,[98,169,170],{},"  !$omp end parallel do\n",[98,172,174],{"class":100,"line":173},13,[98,175,128],{"emptyLinePlaceholder":7},[98,177,179],{"class":100,"line":178},14,[98,180,181],{},"  print *, \"Sum is: \", total_sum\n",[98,183,185],{"class":100,"line":184},15,[98,186,187],{},"end subroutine\n",[69,189,191],{"id":190},"compliant-solution","Compliant Solution",[42,193,194,195,197],{},"In this compliant solution, the ",[52,196,54],{}," OpenMP clause is used as it provides the most efficient way to execute reduction operations in parallel. This automatically creates a private copy of the variable for each thread and combines the results once all threads have finished.",[85,199,201],{"quality":200},"good",[89,202,204],{"className":91,"code":203,"language":93,"meta":94,"style":94},"subroutine calculate_sum(array)\n  implicit none\n  integer, intent(in) :: array(:)\n  integer             :: i, total_sum\n\n  total_sum = 0\n  ! Compliant: Using the reduction clause for safe parallelization\n  !$omp parallel do default(none) private(i) shared(array) reduction(+: total_sum)\n  do i = 1, size(array)\n    total_sum = total_sum + array(i)\n  end do\n  !$omp end parallel do\n\n  print *, \"Sum is: \", total_sum\nend subroutine\n",[52,205,206,210,214,218,222,226,230,235,240,244,248,252,256,260,264],{"__ignoreMap":94},[98,207,208],{"class":100,"line":101},[98,209,104],{},[98,211,212],{"class":100,"line":107},[98,213,110],{},[98,215,216],{"class":100,"line":113},[98,217,116],{},[98,219,220],{"class":100,"line":119},[98,221,122],{},[98,223,224],{"class":100,"line":125},[98,225,128],{"emptyLinePlaceholder":7},[98,227,228],{"class":100,"line":131},[98,229,134],{},[98,231,232],{"class":100,"line":137},[98,233,234],{},"  ! Compliant: Using the reduction clause for safe parallelization\n",[98,236,237],{"class":100,"line":143},[98,238,239],{},"  !$omp parallel do default(none) private(i) shared(array) reduction(+: total_sum)\n",[98,241,242],{"class":100,"line":149},[98,243,152],{},[98,245,246],{"class":100,"line":155},[98,247,158],{},[98,249,250],{"class":100,"line":161},[98,251,164],{},[98,253,254],{"class":100,"line":167},[98,255,170],{},[98,257,258],{"class":100,"line":173},[98,259,128],{"emptyLinePlaceholder":7},[98,261,262],{"class":100,"line":178},[98,263,181],{},[98,265,266],{"class":100,"line":184},[98,267,187],{},[42,269,270,271,274],{},"Alternatively, the ",[52,272,273],{},"atomic update"," OpenMP directive can be used to ensure that only one thread performs the specific addition at a time.",[85,276,277],{"quality":200},[89,278,280],{"className":91,"code":279,"language":93,"meta":94,"style":94},"subroutine calculate_sum(array)\n  implicit none\n  integer, intent(in) :: array(:)\n  integer             :: i, total_sum\n\n  total_sum = 0\n\n  ! Compliant: Using atomic update to protect the shared variable\n  !$omp parallel do default(none) private(i) shared(array, total_sum)\n  do i = 1, size(array)\n    !$omp atomic update\n    total_sum = total_sum + array(i)\n  end do\n  !$omp end parallel do \n\n  print *, \"Sum is: \", total_sum\nend subroutine\n",[52,281,282,286,290,294,298,302,306,310,315,319,323,328,332,336,341,345,350],{"__ignoreMap":94},[98,283,284],{"class":100,"line":101},[98,285,104],{},[98,287,288],{"class":100,"line":107},[98,289,110],{},[98,291,292],{"class":100,"line":113},[98,293,116],{},[98,295,296],{"class":100,"line":119},[98,297,122],{},[98,299,300],{"class":100,"line":125},[98,301,128],{"emptyLinePlaceholder":7},[98,303,304],{"class":100,"line":131},[98,305,134],{},[98,307,308],{"class":100,"line":137},[98,309,128],{"emptyLinePlaceholder":7},[98,311,312],{"class":100,"line":143},[98,313,314],{},"  ! Compliant: Using atomic update to protect the shared variable\n",[98,316,317],{"class":100,"line":149},[98,318,146],{},[98,320,321],{"class":100,"line":155},[98,322,152],{},[98,324,325],{"class":100,"line":161},[98,326,327],{},"    !$omp atomic update\n",[98,329,330],{"class":100,"line":167},[98,331,158],{},[98,333,334],{"class":100,"line":173},[98,335,164],{},[98,337,338],{"class":100,"line":178},[98,339,340],{},"  !$omp end parallel do \n",[98,342,343],{"class":100,"line":184},[98,344,128],{"emptyLinePlaceholder":7},[98,346,348],{"class":100,"line":347},16,[98,349,181],{},[98,351,353],{"class":100,"line":352},17,[98,354,187],{},[69,356,358],{"id":357},"risk-assessment","Risk Assessment",[42,360,361],{},"Failing to protect reduction variables leads to data integrity violations where results are inconsistent and depend on thread timing. This can lead to incorrect state management or information disclosure.",[363,364,365,393],"table",{},[366,367,368],"thead",{},[369,370,371,375,378,381,384,387,390],"tr",{},[372,373,374],"th",{},"Rule",[372,376,377],{},"Severity",[372,379,380],{},"Likelihood",[372,382,383],{},"Detectable",[372,385,386],{},"Repairable",[372,388,389],{},"Priority",[372,391,392],{},"Level",[394,395,396],"tbody",{},[369,397,398,402,405,408,411,413,419],{},[399,400,401],"td",{},"CON02-F",[399,403,404],{},"High",[399,406,407],{},"Likely",[399,409,410],{},"Yes",[399,412,410],{},[399,414,415],{},[416,417,418],"strong",{},"P27",[399,420,421],{},[416,422,423],{},"L1",[425,426],"hr",{},[69,428,430],{"id":429},"bibliography","Bibliography",[42,432,433,434,441],{},"[ ",[435,436,440],"a",{"href":437,"rel":438},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[439],"nofollow","Fortran 2023 Interpretation Document"," - Section 11.1.7.5 and Table 11.1 and 16.5  ]",[42,443,444,451,452,451,458],{},[435,445,447],{"href":446},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[448,449],"img",{"src":450},"attachments\u002F629047343\u002F638779591.png"," ",[435,453,455],{"href":454},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[448,456],{"src":457},"attachments\u002F629047343\u002F638779592.png",[435,459,461],{"href":460},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[448,462],{"src":463},"attachments\u002F629047343\u002F638779593.png",[69,465,467],{"id":466},"attachments","Attachments:",[469,470,474],"div",{"className":471,"align":473},[472],"greybox","left",[42,475,476,451,479,482,483,486,451,488,482,491,493,451,495,482],{},[448,477],{"alt":94,"src":478},"images\u002Ficons\u002Fbullet_blue.gif",[435,480,481],{"href":450},"button_arrow_left.png"," (image\u002Fpng)",[484,485],"br",{},[448,487],{"alt":94,"src":478},[435,489,490],{"href":457},"button_arrow_up.png",[484,492],{},[448,494],{"alt":94,"src":478},[435,496,497],{"href":463},"button_arrow_right.png",[499,500,501],"style",{},"html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}",{"title":94,"searchDepth":107,"depth":107,"links":503},[504,505,506,507,508],{"id":71,"depth":107,"text":72},{"id":190,"depth":107,"text":191},{"id":357,"depth":107,"text":358},{"id":429,"depth":107,"text":430},{"id":466,"depth":107,"text":467},"md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon02-f",{"title":33,"description":44},"9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F3.con02-f","g14uMT2X-2odvgA2OlBBuFg6CLpbCovSaFboN12CNK0",[516,520],{"title":517,"path":518,"stem":519,"children":-1},"CON01-F. Explicitly declare OpenMP data-sharing attributes for all variables","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F2.con01-f",{"title":521,"path":522,"stem":523,"children":-1},"CON03-F. Protect multithreading recurrences to avoid data races","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F4.con03-f",[525],{"title":526,"path":527,"stem":528,"children":529},"SEI CERT Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard\u002F01.index",[530,531,543,698],{"title":526,"path":527,"stem":528},{"title":532,"path":533,"stem":534,"children":535},"Front Matter","\u002Fsei-cert-fortran-coding-standard\u002Ffront-matter","9.sei-cert-fortran-coding-standard\u002F02.front-matter\u002F1.index",[536,537],{"title":532,"path":533,"stem":534},{"title":538,"path":539,"stem":540,"children":541},"Introduction","\u002Fsei-cert-fortran-coding-standard\u002Ffront-matter\u002Fintroduction","9.sei-cert-fortran-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[542],{"title":538,"path":539,"stem":540},{"title":544,"path":545,"stem":546,"children":547},"Guidelines","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F01.index",[548,549,571,585,602,612,622,640,658,676],{"title":544,"path":545,"stem":546},{"title":550,"path":551,"stem":552,"children":553},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F1.index",[554,555,559,563,567],{"title":550,"path":551,"stem":552},{"title":556,"path":557,"stem":558},"ARR01-F. Do not use out-of-bounds arrays subscripts","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F2.arr01-f",{"title":560,"path":561,"stem":562},"ARR02-F. Declare array dummy arguments as assumed-shape","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F3.arr02-f",{"title":564,"path":565,"stem":566},"ARR03-F. Specify array bounds when copying data to device memory","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F4.arr03-f",{"title":568,"path":569,"stem":570},"ARR04-F. Ensure arrays ranges mapped to devices cover all accessed elements","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F5.arr04-f",{"title":572,"path":573,"stem":574,"children":575},"Attribute Declarations and Specifications (ADS)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fattribute-declarations-and-specifications-ads","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.attribute-declarations-and-specifications-ads\u002F1.index",[576,577,581],{"title":572,"path":573,"stem":574},{"title":578,"path":579,"stem":580},"ADS01-F. Explicitly declare pure procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fattribute-declarations-and-specifications-ads\u002Fads01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads01-f",{"title":582,"path":583,"stem":584},"ADS02-F. Separate initialization from declaration to avoid implicit variable persistence","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fattribute-declarations-and-specifications-ads\u002Fads02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads02-f",{"title":586,"path":587,"stem":588,"children":589},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F1.index",[590,591,592,593,594,598],{"title":586,"path":587,"stem":588},{"title":517,"path":518,"stem":519},{"title":33,"path":511,"stem":513},{"title":521,"path":522,"stem":523},{"title":595,"path":596,"stem":597},"CON04-F. Do not use out-of-dimension subscripts in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F5.con04-f",{"title":599,"path":600,"stem":601},"CON05-F. Ensure correct OpenMP datascoping of variables in parallel regions","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon05-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F6.con05-f",{"title":603,"path":604,"stem":605,"children":606},"Exceptions and IEEE Arithmetic (EIA)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexceptions-and-ieee-arithmetic-eia","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F05.exceptions-and-ieee-arithmetic-eia\u002F1.index",[607,608],{"title":603,"path":604,"stem":605},{"title":609,"path":610,"stem":611},"EIA01-F. Enforce evaluation order in floating-point expressions","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexceptions-and-ieee-arithmetic-eia\u002Feia01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F05.exceptions-and-ieee-arithmetic-eia\u002F2.eia01-f",{"title":613,"path":614,"stem":615,"children":616},"Expressions and Assignment (EXA)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexpressions-and-assignment-exa","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F07.expressions-and-assignment-exa\u002F1.index",[617,618],{"title":613,"path":614,"stem":615},{"title":619,"path":620,"stem":621},"EXA01-F. Do not read uninitialized memory","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexpressions-and-assignment-exa\u002Fexa01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F07.expressions-and-assignment-exa\u002F2.exa01-f",{"title":623,"path":624,"stem":625,"children":626},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F1.index",[627,628,632,636],{"title":623,"path":624,"stem":625},{"title":629,"path":630,"stem":631},"MSC01-F. Avoid using legacy or obsolescent Fortran constructs","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc\u002Fmsc01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F2.msc01-f",{"title":633,"path":634,"stem":635},"MSC02-F. Beware of compiler-specific extensions","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc\u002Fmsc02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F3.msc02-f",{"title":637,"path":638,"stem":639},"MSC03-F. Do not depend on undefined behavior","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc\u002Fmsc03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F4.msc03-f",{"title":641,"path":642,"stem":643,"children":644},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F1.index",[645,646,650,654],{"title":641,"path":642,"stem":643},{"title":647,"path":648,"stem":649},"PRC01-F. Disable the implicit declaration of procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc\u002Fprc01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F2.prc01-f",{"title":651,"path":652,"stem":653},"PRC02-F. Avoid implicit interfaces by using module procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc\u002Fprc02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F3.prc02-f",{"title":655,"path":656,"stem":657},"PRC03-F. Declare the intent for all dummy arguments","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc\u002Fprc03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F4.prc03-f",{"title":659,"path":660,"stem":661,"children":662},"Scope, Association, and Definition (SAD)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F1.index",[663,664,668,672],{"title":659,"path":660,"stem":661},{"title":665,"path":666,"stem":667},"SAD02-F. Minimize imported module entities using the ONLY clause","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad\u002Fsad02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F2.sad02-f",{"title":669,"path":670,"stem":671},"SAD03-F. Replace common block with modules for safer data encapsulation","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad\u002Fsad03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F3.sad03-f",{"title":673,"path":674,"stem":675},"Limit the scope of variables and procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad\u002Flimit-the-scope-of-variables-and-procedures","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F4.limit-the-scope-of-variables-and-procedures",{"title":677,"path":678,"stem":679,"children":680},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F1.index",[681,682,686,690,694],{"title":677,"path":678,"stem":679},{"title":683,"path":684,"stem":685},"TYP01-F. Use Intrinsic Assignment for Character Entities","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F2.typ01-f",{"title":687,"path":688,"stem":689},"TYP02-F. Prohibit implicit typing in all program units","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F3.typ02-f",{"title":691,"path":692,"stem":693},"TYP03-F. Ensure intrinsic function arguments match intended precision","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F4.typ03-f",{"title":695,"path":696,"stem":697},"TYP04-F. Centralize kind definitions to ensure consistent precision","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F5.typ04-f",{"title":699,"path":700,"stem":701},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1783713877459]