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