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