offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/malloc--afar-device-malloc-in-kernel-corrupts-records.json

@@ -0,0 +1,270 @@
+{
+ "finding": "malloc/afar-device-malloc-in-kernel-corrupts-records.c",
+ "readers": [
+  {
+   "run": "run-20261112/batch-12",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "The target region calls malloc, memcpy and free, which are external functions without a declare target directive and are not defined in the translation unit; the specification gives no guarantee they are device routines, so acceptance and behavior are not clearly required. tmp is also used without a null check. The pointer gpp is implicitly a zero-length-section base pointer and attaches to the alloc-mapped gps storage; indices li are unique per iteration, so no race otherwise. Because the device heap is not specified by the standard, the observed wrong answer is not clearly a spec violation."
+  },
+  {
+   "run": "run-20261112/batch-32",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Each iteration writes a distinct element, so no race, and gpp (a firstprivate pointer) is translated to the mapped gps storage per 5.8.6. But the program calls malloc on the device for ~48M concurrent iterations and dereferences the result unchecked; device heap size and malloc failure behaviour are not specified by OpenMP, so a failed or exhausted device allocation (bad 4220 in trial 1 only) is not something the specification rules out. No clause of the spec requires the expected result."
+  },
+  {
+   "run": "run-v2-20261113/batch-25",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "gpp is a pointer used in the target region without a clause, so it is implicitly mapped as a zero-length array section and resolves to the device copy of gps (mapped with alloc). The program is conforming. The kernel calls device malloc/free and memcpy on 4 million-plus threads and dereferences tmp without a null check. The specification says nothing about device-side malloc, its heap size or its failure behavior, so wrong results from heap exhaustion or races in the device allocator are not excluded by the specification.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-45",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-73",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The device code calls malloc, memcpy and free, which have no visible definition, so the implicit declare target rule does not cover them and the specification does not define their behavior on a device. The device-side allocator is not specified to be thread-safe or visible across teams. The wrong answer is therefore not clearly a violation of a required result.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-60",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": true,
+     "false_claims": [
+      "malloc/memcpy/free have no visible definition so the implicit declare target rule does not cover them"
+     ],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-01",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "f291e10383fcfb60d06c380264ab5d7f738b0410b6bb411f58f4ab0a28fde77c",
+ "instructions": "v2",
+ "verdict": "contested",
+ "why": "An independent adjudicating reading finds the result not required: The failure is in device-side malloc, memcpy and free, which the specification treats only as procedures referenced in a target construct. Nothing in the specification defines their device behavior, heap size or failure handling for millions of threads, so wrong results from an exhausted device heap are not excluded.",
+ "adjudicators": [
+  {
+   "run": "adj-20261112/batch-01",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Both readings reach the same verdict and it holds. Each iteration writes a distinct element, so there is no race and gpp is attached to the mapped gps storage. The specification does not define device heap capacity or behaviour of malloc called in a target region, and the program dereferences the result without a null check; a failed device allocation under 48M concurrent iterations is not excluded. Nothing in the text requires check=pass."
+  },
+  {
+   "run": "adj-20261112/batch-05",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Both readings reach the same verdict and it holds. Each iteration writes a distinct element, so there is no race, and gpp is translated via the mapped gps storage. The risk is the target region calling malloc, memcpy and free, which are external functions that are neither declared target nor defined in the translation unit; the implicit declare target rules cover only functions referenced from declare target procedures. The specification does not guarantee device versions of these, nor device heap capacity or malloc success, and the code dereferences malloc results unchecked, so the observed bad entries in one trial are not excluded."
+  },
+  {
+   "run": "adj-v2-20261113b/batch-02",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Reading A is mostly right on mapping: gpp is implicitly a zero-length array section and attaches to the present gps storage. The failure is in device-side malloc, memcpy and free, which the specification treats only as procedures referenced in a target construct. Nothing in the specification defines their device behavior, heap size or failure handling for millions of threads, so wrong results from an exhausted device heap are not excluded. Reading B is right that the result is not required, but legality of the unspecified library behavior is not decided.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-19",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113b/batch-08",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "gpp is a pointer referenced in the target region, so it is treated as a zero-length array section and attaches to the device copy of gps. The program is legal. The specification says nothing about device-side malloc, memcpy or free behavior under heavy concurrency, so the wrong answer is not shown to violate a requirement. Reading B's claim that legality is uncertain is not supported.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-64",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-04",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113c/batch-01",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/multithread-allocatable-section-maps.json

@@ -0,0 +1,191 @@
+{
+ "finding": "multithread-allocatable-section-maps.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-07",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Each of two threads encounters a target construct mapping disjoint array sections of the allocatable arrays a and b; the sections do not overlap, the arrays are not reallocated while mapped, and lo/hi are private. The shared i is only read for implicit firstprivate and is not written on the host inside the region. No data race; both halves of b must be computed, so bad=32 is a compiler error."
+  },
+  {
+   "run": "run-20261112/batch-27",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Each of the two threads encounters its own target construct mapping a disjoint section of a and b; lo and hi are private, i is private (loop iteration variable inside parallel, firstprivate in target). No race, no overlap of mapped sections, and the allocatable is not modified in the region. Each section must be mapped to/from the device, so all 64 results must be correct; bad=32 means one thread's data was lost, a compiler bug."
+  },
+  {
+   "run": "run-v2-20261113/batch-03",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Two threads each execute a target region mapping disjoint sections of the allocatable arrays a and b. The loop variable i of the sequential loop inside parallel is private, and lo and hi are private. No race exists and no mapping rule is broken, so b must be fully computed and bad must be 0.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-44",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-106",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The two threads map disjoint sections a(1:32) and a(33:64) of the same allocatable array on one device, so there is no overlap and no race on b. But both sections derive from the same allocatable variable, whose descriptor is shared on the device. The target restrictions leave behavior unspecified when the variable is modified in the region, and the spec does not say how concurrent attachment of one descriptor to two different sections behaves. Whether a conforming implementation must copy back both halves is not settled by the text.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-05",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "0eb4d743bab627b467a9ca784e35a09915a13fd0a8a3613ca120bfef2680e06c",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "One independent reading was uncertain; 2 adjudicating readings that weighed both find the program legal and the result required: The two host threads map disjoint sections a(lo:hi) and b(lo:hi), and the target region references only elements inside the mapped sections. The only stated restriction (whole-array reference to a partly mapped array) is not triggered, and the variable is not allocated, deallocated or reshaped meanwhile. i, lo and hi are private.",
+ "adjudicators": [
+  {
+   "run": "adj-v2-20261113/batch-02",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Reading B's doubt fails. The two host threads map disjoint sections a(lo:hi) and b(lo:hi), and the target region references only elements inside the mapped sections. The only stated restriction (whole-array reference to a partly mapped array) is not triggered, and the variable is not allocated, deallocated or reshaped meanwhile. i, lo and hi are private. Reading A is right: the program is conforming and bad=0 is required.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-61",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113/batch-13",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Each thread runs its own target construct with a disjoint array section of a and b, so the sections do not overlap. The allocatable arrays are not allocated, deallocated, reshaped or modified in the regions, so the allocatable restrictions are not triggered. lo and hi are private, and i is only read on the host (it is a private copy in each target region). No race exists. Reading B cites no passage making concurrent mapping of different sections of one allocatable unspecified. Each half of b must be copied back, so bad=0.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-21",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/nested--afar-cce-c-call-result-member-in-target-rejected.json

@@ -0,0 +1,113 @@
+{
+ "finding": "nested/afar-cce-c-call-result-member-in-target-rejected.c",
+ "readers": [
+  {
+   "run": "run-20261113/batch-24",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "r[0:1], r->nx[0:1] and r->nx->a[0:4] are disjoint storage and the pointers are attached; child is declare target and only dereferences mapped storage. Single-threaded device region, no race. The reported 'map clause' error refers to an expression not in a map clause, so it is a compiler bug."
+  },
+  {
+   "run": "run-20261113/batch-80",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "map(to: r[0:1]), r->nx[0:1] and r->nx->a[0:4] are valid array sections of lvalue base expressions; pointer members are attached. The declare target function only dereferences pointers that are attached in the device environment. tot is updated by a single initial thread, no race. The refusal of the use in the body is not required by the specification."
+  },
+  {
+   "run": "run-v2-20261113/batch-50",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The map clauses name valid array sections (r[0:1], r->nx[0:1], r->nx->a[0:4]) that map the full pointer chain, and child is a declare target function. The expression child(r)->a[q] is only used in the region body, not in a map clause, so the compiler diagnostic is spurious. A conforming compiler must accept it.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-20",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-94",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "r[0:1], r->nx[0:1] and r->nx->a[0:4] are distinct storage, so no sharing restriction is broken. The pointers are attached on the device and child() is in a declare target region. The accepted call child(r)->a[q] is conforming. The refusal message cites a line the program does not contain.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-19",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "338660722abe38ed0b6fb0fa67de69674789cffdaa77f1534cadac228aec86ae",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}