[{"data":1,"prerenderedAt":851},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon05-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon05-f":657,"sidebar-sei-cert-fortran-coding-standard":666},[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":650,"extension":651,"meta":652,"navigation":7,"path":653,"seo":654,"stem":655,"__hash__":656},"content\u002F9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F6.con05-f.md","CON05-F. Ensure correct OpenMP datascoping of variables in parallel regions",{"type":35,"value":36,"toc":640},"minimark",[37,41,57,60,79,86,91,106,199,203,219,257,260,276,340,343,355,372,375,385,465,468,474,491,495,498,576,579,602,606,636],[38,39,33],"h1",{"id":40},"con05-f-ensure-correct-openmp-datascoping-of-variables-in-parallel-regions",[42,43,44,45,49,50,49,53,56],"p",{},"Developers shall correctly specify data-sharing attributes ( ",[46,47,48],"code",{},"shared"," , ",[46,51,52],{},"private",[46,54,55],{},"lastprivate"," , etc.) for all variables in OpenMP parallel regions to prevent data races, undefined behavior, and incorrect results.",[42,58,59],{},"In multithreaded code, data races occur when multiple threads access the same memory location concurrently, with at least one write and no proper synchronization. Incorrect OpenMP data-scoping manifests mainly in three ways:",[61,62,63,67,73],"ul",{},[64,65,66],"li",{},"Incorrect sharing: A variable that should be local to each thread (e.g., loop iterators) is implicitly shared, causing threads to overwrite the same memory location.",[64,68,69,70,72],{},"Incorrect privatization: A variable intended to aggregate results or maintain ga lobal state is declared ",[46,71,52],{}," , so each thread updates its local copy, and changes are lost.",[64,74,75,76,78],{},"Missing ",[46,77,55],{}," : A variable correctly privatized for a loop does not retain the value from the logically last iteration, leading to inconsistent post-loop results.",[42,80,81,82,85],{},"Using ",[46,83,84],{},"default(none)"," in combination with explicit attribute declarations enforces safe, predictable data-scoping and prevents accidental sharing or privatization errors.",[87,88,90],"h2",{"id":89},"noncompliant-code-example","Noncompliant Code Example",[42,92,93,94,97,98,101,102,105],{},"In this example, the temporary variable ",[46,95,96],{},"scaling_factor"," is shared among all threads because it is not declared ",[46,99,100],{},"private."," Each thread overwrites the same memory location, causing a data race when multiple threads simultaneously compute and assign to ",[46,103,104],{},"A(i)"," .",[107,108,110],"code-block",{"quality":109},"bad",[111,112,117],"pre",{"className":113,"code":114,"language":115,"meta":116,"style":116},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","subroutine apply_weights(A, B, weight)\n  implicit none\n  real, intent(inout) :: A(:)\n  real, intent(in)    :: B(:), weight\n  real                :: scaling_factor\n  integer             :: i\n\n  !$omp parallel do shared(A, B, weight, scaling_factor)\n    do i = 1, size(A)\n        scaling_factor = B(i) * weight\n        A(i) = A(i) + scaling_factor\n    end do\nend subroutine\n","fortran","",[46,118,119,127,133,139,145,151,157,163,169,175,181,187,193],{"__ignoreMap":116},[120,121,124],"span",{"class":122,"line":123},"line",1,[120,125,126],{},"subroutine apply_weights(A, B, weight)\n",[120,128,130],{"class":122,"line":129},2,[120,131,132],{},"  implicit none\n",[120,134,136],{"class":122,"line":135},3,[120,137,138],{},"  real, intent(inout) :: A(:)\n",[120,140,142],{"class":122,"line":141},4,[120,143,144],{},"  real, intent(in)    :: B(:), weight\n",[120,146,148],{"class":122,"line":147},5,[120,149,150],{},"  real                :: scaling_factor\n",[120,152,154],{"class":122,"line":153},6,[120,155,156],{},"  integer             :: i\n",[120,158,160],{"class":122,"line":159},7,[120,161,162],{"emptyLinePlaceholder":7},"\n",[120,164,166],{"class":122,"line":165},8,[120,167,168],{},"  !$omp parallel do shared(A, B, weight, scaling_factor)\n",[120,170,172],{"class":122,"line":171},9,[120,173,174],{},"    do i = 1, size(A)\n",[120,176,178],{"class":122,"line":177},10,[120,179,180],{},"        scaling_factor = B(i) * weight\n",[120,182,184],{"class":122,"line":183},11,[120,185,186],{},"        A(i) = A(i) + scaling_factor\n",[120,188,190],{"class":122,"line":189},12,[120,191,192],{},"    end do\n",[120,194,196],{"class":122,"line":195},13,[120,197,198],{},"end subroutine\n",[87,200,202],{"id":201},"compliant-solution","Compliant Solution",[42,204,205,206,208,209,211,212,215,216,218],{},"The compliant solution uses ",[46,207,84],{}," and explicitly marks the scalar as ",[46,210,52],{}," so each thread has its own isolated instance. Note that the variable ",[46,213,214],{},"i"," is implicitly ",[46,217,52],{}," as it is the iteration variable.",[107,220,222],{"quality":221},"good",[111,223,225],{"className":113,"code":224,"language":115,"meta":116,"style":116},"! Compliant: scaling_factor is now local to each thread.\n  !$omp parallel do default(none) shared(A, B, weight) private(scaling_factor)\n  do i = 1, size(A)\n    scaling_factor = B(i) * weight\n    A(i) = A(i) + scaling_factor\n  end do\n",[46,226,227,232,237,242,247,252],{"__ignoreMap":116},[120,228,229],{"class":122,"line":123},[120,230,231],{},"! Compliant: scaling_factor is now local to each thread.\n",[120,233,234],{"class":122,"line":129},[120,235,236],{},"  !$omp parallel do default(none) shared(A, B, weight) private(scaling_factor)\n",[120,238,239],{"class":122,"line":135},[120,240,241],{},"  do i = 1, size(A)\n",[120,243,244],{"class":122,"line":141},[120,245,246],{},"    scaling_factor = B(i) * weight\n",[120,248,249],{"class":122,"line":147},[120,250,251],{},"    A(i) = A(i) + scaling_factor\n",[120,253,254],{"class":122,"line":153},[120,255,256],{},"  end do\n",[87,258,90],{"id":259},"noncompliant-code-example-1",[42,261,262,263,266,267,269,270,272,273,275],{},"In this example, the programmer intends to populate the ",[46,264,265],{},"results"," array. However, by marking ",[46,268,265],{}," as ",[46,271,52],{}," , the threads operate on local copies that are not synchronized with the actual array on the host. Consequently, the ",[46,274,265],{}," array remains unchanged after the subroutine executes.",[107,277,278],{"quality":109},[111,279,281],{"className":113,"code":280,"language":115,"meta":116,"style":116},"subroutine compute_log(input, results)\n  implicit none\n  real, intent(in)    :: input(:)\n  real, intent(inout) :: results(:)\n  integer :: i\n\n  ! Noncompliant: results array is privatized; host updates are lost\n  !$omp parallel do private(i, results) shared(input)\n  do i = 1, size(input)\n    results(i) = log(input(i))\n  end do\nend subnroutine\n",[46,282,283,288,292,297,302,307,311,316,321,326,331,335],{"__ignoreMap":116},[120,284,285],{"class":122,"line":123},[120,286,287],{},"subroutine compute_log(input, results)\n",[120,289,290],{"class":122,"line":129},[120,291,132],{},[120,293,294],{"class":122,"line":135},[120,295,296],{},"  real, intent(in)    :: input(:)\n",[120,298,299],{"class":122,"line":141},[120,300,301],{},"  real, intent(inout) :: results(:)\n",[120,303,304],{"class":122,"line":147},[120,305,306],{},"  integer :: i\n",[120,308,309],{"class":122,"line":153},[120,310,162],{"emptyLinePlaceholder":7},[120,312,313],{"class":122,"line":159},[120,314,315],{},"  ! Noncompliant: results array is privatized; host updates are lost\n",[120,317,318],{"class":122,"line":165},[120,319,320],{},"  !$omp parallel do private(i, results) shared(input)\n",[120,322,323],{"class":122,"line":171},[120,324,325],{},"  do i = 1, size(input)\n",[120,327,328],{"class":122,"line":177},[120,329,330],{},"    results(i) = log(input(i))\n",[120,332,333],{"class":122,"line":183},[120,334,256],{},[120,336,337],{"class":122,"line":189},[120,338,339],{},"end subnroutine\n",[87,341,202],{"id":342},"compliant-solution-1",[42,344,345,346,348,349,351,352,354],{},"In the compliant version, the ",[46,347,265],{}," array is no longer privatized. Instead, it is explicitly declared as ",[46,350,48],{}," , ensuring that updates performed by each thread are applied to the host-visible array. Using ",[46,353,84],{}," enforces explicit data-sharing attributes and prevents accidental privatization.",[107,356,357],{"quality":221},[111,358,360],{"className":113,"code":359,"language":115,"meta":116,"style":116},"! Compliant: results is shared so updates are visible outside the region\n!$omp parallel do default(none) private(i) shared(input, results) \n",[46,361,362,367],{"__ignoreMap":116},[120,363,364],{"class":122,"line":123},[120,365,366],{},"! Compliant: results is shared so updates are visible outside the region\n",[120,368,369],{"class":122,"line":129},[120,370,371],{},"!$omp parallel do default(none) private(i) shared(input, results)\n",[87,373,90],{"id":374},"noncompliant-code-example-2",[42,376,262,377,266,379,269,381,272,383,275],{},[46,378,265],{},[46,380,265],{},[46,382,52],{},[46,384,265],{},[107,386,387],{"quality":109},[111,388,390],{"className":113,"code":389,"language":115,"meta":116,"style":116},"real function process_increment(data)\n  implicit none\n  real, intent(in) :: data(:)\n  real             :: last_val\n  integer          :: i\n\n  ! Noncompliant: last_val is private, so tis value is lost after \n  ! the loop.\n  !$omp parallel do private(i, last_val) shared(data)\n  do i = 1, size(data)\n     last_val = data(i) * 2.0\n  end do\n\n  process_increment = last_val + 10.0\nend function\n",[46,391,392,397,401,406,411,416,420,425,430,435,440,445,449,453,459],{"__ignoreMap":116},[120,393,394],{"class":122,"line":123},[120,395,396],{},"real function process_increment(data)\n",[120,398,399],{"class":122,"line":129},[120,400,132],{},[120,402,403],{"class":122,"line":135},[120,404,405],{},"  real, intent(in) :: data(:)\n",[120,407,408],{"class":122,"line":141},[120,409,410],{},"  real             :: last_val\n",[120,412,413],{"class":122,"line":147},[120,414,415],{},"  integer          :: i\n",[120,417,418],{"class":122,"line":153},[120,419,162],{"emptyLinePlaceholder":7},[120,421,422],{"class":122,"line":159},[120,423,424],{},"  ! Noncompliant: last_val is private, so tis value is lost after \n",[120,426,427],{"class":122,"line":165},[120,428,429],{},"  ! the loop.\n",[120,431,432],{"class":122,"line":171},[120,433,434],{},"  !$omp parallel do private(i, last_val) shared(data)\n",[120,436,437],{"class":122,"line":177},[120,438,439],{},"  do i = 1, size(data)\n",[120,441,442],{"class":122,"line":183},[120,443,444],{},"     last_val = data(i) * 2.0\n",[120,446,447],{"class":122,"line":189},[120,448,256],{},[120,450,451],{"class":122,"line":195},[120,452,162],{"emptyLinePlaceholder":7},[120,454,456],{"class":122,"line":455},14,[120,457,458],{},"  process_increment = last_val + 10.0\n",[120,460,462],{"class":122,"line":461},15,[120,463,464],{},"end function\n",[87,466,202],{"id":467},"compliant-solution-2",[42,469,470,471,473],{},"The ",[46,472,55],{}," clause ensures that the value from the iteration that would be the last in a sequential execution is copied back to the host variable.",[107,475,476],{"quality":221},[111,477,479],{"className":113,"code":478,"language":115,"meta":116,"style":116},"! Compliant: lastprivate preserves the value for use after the loop\n!$omp parallel do default(none) lastprivate(last_val) shared(data) private(i) \n",[46,480,481,486],{"__ignoreMap":116},[120,482,483],{"class":122,"line":123},[120,484,485],{},"! Compliant: lastprivate preserves the value for use after the loop\n",[120,487,488],{"class":122,"line":129},[120,489,490],{},"!$omp parallel do default(none) lastprivate(last_val) shared(data) private(i)\n",[87,492,494],{"id":493},"risk-assessment","Risk Assessment",[42,496,497],{},"Incorrect OpenMP data-scoping can lead to data races, causing non-deterministic behavior and potential security vulnerabilities.",[499,500,501,522],"table",{},[502,503,504],"thead",{},[505,506,507,510,512,514,516,518,520],"tr",{},[508,509],"th",{},[508,511],{},[508,513],{},[508,515],{},[508,517],{},[508,519],{},[508,521],{},[523,524,525,549],"tbody",{},[505,526,527,531,534,537,540,543,546],{},[528,529,530],"td",{},"Recommendation",[528,532,533],{},"Severity",[528,535,536],{},"Likelihood",[528,538,539],{},"Detectable",[528,541,542],{},"Repairable",[528,544,545],{},"Priority",[528,547,548],{},"Level",[505,550,551,554,557,560,563,565,571],{},[528,552,553],{},"CON05-F",[528,555,556],{},"High",[528,558,559],{},"Likely",[528,561,562],{},"Yes",[528,564,562],{},[528,566,567],{},[568,569,570],"strong",{},"P27",[528,572,573],{},[568,574,575],{},"L1",[577,578],"hr",{},[42,580,581,589,590,589,596],{},[582,583,585],"a",{"href":584},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[586,587],"img",{"src":588},"attachments\u002F629047357\u002F638779603.png"," ",[582,591,593],{"href":592},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[586,594],{"src":595},"attachments\u002F629047357\u002F638779604.png",[582,597,599],{"href":598},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[586,600],{"src":601},"attachments\u002F629047357\u002F638779605.png",[87,603,605],{"id":604},"attachments","Attachments:",[607,608,612],"div",{"className":609,"align":611},[610],"greybox","left",[42,613,614,589,617,620,621,624,589,626,620,629,631,589,633,620],{},[586,615],{"alt":116,"src":616},"images\u002Ficons\u002Fbullet_blue.gif",[582,618,619],{"href":588},"button_arrow_left.png"," (image\u002Fpng)",[622,623],"br",{},[586,625],{"alt":116,"src":616},[582,627,628],{"href":595},"button_arrow_up.png",[622,630],{},[586,632],{"alt":116,"src":616},[582,634,635],{"href":601},"button_arrow_right.png",[637,638,639],"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":116,"searchDepth":129,"depth":129,"links":641},[642,643,644,645,646,647,648,649],{"id":89,"depth":129,"text":90},{"id":201,"depth":129,"text":202},{"id":259,"depth":129,"text":90},{"id":342,"depth":129,"text":202},{"id":374,"depth":129,"text":90},{"id":467,"depth":129,"text":202},{"id":493,"depth":129,"text":494},{"id":604,"depth":129,"text":605},"Developers shall correctly specify data-sharing attributes ( shared , private , lastprivate , etc.) for all variables in OpenMP parallel regions to prevent data races, undefined behavior, and incorrect results.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon05-f",{"title":33,"description":650},"9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F6.con05-f","j5wn9q5MoIyW77dC6OIRwMyW-AGg4pPvTBzaETu4mc0",[658,662],{"title":659,"path":660,"stem":661,"children":-1},"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":663,"path":664,"stem":665,"children":-1},"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",[667],{"title":668,"path":669,"stem":670,"children":671},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[672,675,697,711,731,738,742,752,756,760,764,768,786,804,808,826,847],{"title":673,"path":669,"stem":674},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":676,"path":677,"stem":678,"children":679},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[680,681,685,689,693],{"title":676,"path":677,"stem":678},{"title":682,"path":683,"stem":684},"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":686,"path":687,"stem":688},"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":690,"path":691,"stem":692},"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":694,"path":695,"stem":696},"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":698,"path":699,"stem":700,"children":701},"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",[702,703,707],{"title":698,"path":699,"stem":700},{"title":704,"path":705,"stem":706},"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":708,"path":709,"stem":710},"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":712,"path":713,"stem":714,"children":715},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[716,717,721,725,729,730],{"title":712,"path":713,"stem":714},{"title":718,"path":719,"stem":720},"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":722,"path":723,"stem":724},"CON02-F. Protect reduction variables in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon02-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F3.con02-f",{"title":726,"path":727,"stem":728},"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",{"title":659,"path":660,"stem":661},{"title":33,"path":653,"stem":655},{"title":663,"path":664,"stem":665,"children":732},[733,734],{"title":663,"path":664,"stem":665},{"title":735,"path":736,"stem":737},"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":739,"path":740,"stem":741},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":743,"path":744,"stem":745,"children":746},"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",[747,748],{"title":743,"path":744,"stem":745},{"title":749,"path":750,"stem":751},"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":753,"path":754,"stem":755},"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":757,"path":758,"stem":759},"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":761,"path":762,"stem":763},"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":765,"path":766,"stem":767},"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":769,"path":770,"stem":771,"children":772},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[773,774,778,782],{"title":769,"path":770,"stem":771},{"title":775,"path":776,"stem":777},"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":779,"path":780,"stem":781},"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":783,"path":784,"stem":785},"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":787,"path":788,"stem":789,"children":790},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[791,792,796,800],{"title":787,"path":788,"stem":789},{"title":793,"path":794,"stem":795},"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":797,"path":798,"stem":799},"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":801,"path":802,"stem":803},"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":805,"path":806,"stem":807},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":809,"path":810,"stem":811,"children":812},"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",[813,814,818,822],{"title":809,"path":810,"stem":811},{"title":815,"path":816,"stem":817},"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":819,"path":820,"stem":821},"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":823,"path":824,"stem":825},"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":827,"path":828,"stem":829,"children":830},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[831,832,835,839,843],{"title":827,"path":828,"stem":829},{"title":833,"path":598,"stem":834},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":836,"path":837,"stem":838},"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":840,"path":841,"stem":842},"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":844,"path":845,"stem":846},"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":848,"path":849,"stem":850},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167744]