ysun67/srdatalog-doop-corrected-xlarge

Corrected DOOP xlarge datasets

Complete raw and prepared static-analysis facts for Soot 4.3.0, Jython (DaCapo 23.11-MR2-chopin), Scala 2.11.12, and Kotlin 1.4.32. This private snapshot packages the four existing xlarge inputs, the corrected SRDatalog query and its reproduction source, and compact evidence of exact CPU/GPU agreement. No input rows are sampled, multiplied, or replaced with synthetic roots.

Correction and validation scope

The corrected query SHA-256 is:

3b9c44856a0a469c48b832e03d8d8f78149a99a765cecb9c80d99cffaa162e94

The historical query had an unguarded Object[] array-store rule. The correction adds unary EligibleObjectArrayHeap(heap) eligibility using HeapAllocation_Type, ComponentType(ObjectArray, comptype), and SupertypeOf(comptype, heaptype). AIPT_Store_ObjectArray joins this eligibility relation, preserving the stored-heap-type/component/subtype guards without materializing the array-heap × stored-heap Cartesian product. The raw archives remain byte-identical to the pinned upstream assets. Prepared inputs and manifests were regenerated in a fresh corrected-query root; this package does not rewrite historical release evidence.

For each of the four datasets, the recorded corrected CPU and GPU runs match all 75 relation cardinalities and all 38 complete IDB tuple sets, without sampling. The query consumes 37 of the 39 declared prepared input relations. CPU uses the Soufflé translation of this same Python query; agreement does not prove complete semantic equivalence to independently executed upstream DOOP or complete Java/reflection coverage.

Jython caveat: the corrected baseline GPU plan failed with CUDA out-of-memory during warmup, even with SRDATALOG_RMM_RESOURCE=cuda_async. Its successful validation uses the bitmap plan. Soot, Scala, and Kotlin use baseline. The failure report and original OOM log are retained in validation/jython/baseline-failed/; no baseline success is claimed. Successful GPU runs use device-only cuda_async on NVIDIA RTX 6000 Ada Generation, not managed memory or host spill. The bitmap option changes the two recursive VPT_Assign variants, not the logical query or inputs.

Reports retain one warmup and three measured fresh-process repetitions where successful. Fixedpoint timing excludes compilation, input loading, GPU database construction/H2D, count collection, and tuple export. Timings describe the recorded workstation sessions, not a controlled hardware comparison or universal speedup. validation/summary.json records the actual plans, timings, corrected VPT counts, and input identities. Old catalog reference_vpt_rows, upstream extraction measurements, and source documentation may describe the historical unguarded query; they are provenance, not replacement corrected results.

Provenance and licensing

• Soot and Scala raw archives: SRDatalog corpus expanded v1.
• Kotlin raw archive: SRDatalog corpus expanded v2, version 1.4.32, not the retired 1.5.31 input.
• Jython raw archive: NemoYuu/flowlog_benchmark, pinned revision da9e91b3ff75d94604f57ba2b21ef3aa97e241ec.

Exact URLs, revisions, application versions, archive sizes and hashes are in provenance/datasets.json and each manifest. The downloaded Soot/Scala/Kotlin extraction provenance retains the DOOP/platform/application/dependency identity and extraction diagnostics, including phantom diagnostics. These are static extracted-fact workloads, not phantom-free or full-language analysis claims.

No blanket license for this combined fact corpus is asserted. The bundled SRDatalog source has its MIT notice in source/LICENSE inside reproduction-source.tar.gz. The pinned upstream Jython dataset card declares Apache-2.0; its original card is included as provenance/jython-upstream-dataset-card.md. That declaration is reported as upstream metadata, not an assertion that it relicenses all analyzed applications, Java platform material, or dependencies. Upstream applications, toolchains, and dependencies retain their respective licenses; consult the linked upstream assets and extraction provenance before redistribution. The repository is private; no new public redistribution permission is implied.

Package layout

raw/{soot,jython,scala,kotlin}.zip       # original pinned ZIPs, APP/*.facts
prepared/{soot,jython,scala,kotlin}.tar.gz
                                      # prepared/APP/{39 *.csv,meta.json,
                                      # str2num.json,manifest.json}
manifests/APP.json                     # standalone copy of each prepared manifest
reproduction-source.tar.gz            # source/ Python query, preparation,
                                      # CPU/GPU runners, compiler/runtime source,
                                      # pinned dependency config and setup scripts
reproduce.sh                          # unpack and run matching CPU/GPU plan matrix
provenance/                           # catalog, extraction/source identities,
                                      # archive integrity results
validation/APP/                       # compact CPU/GPU/build/comparison reports
validation/summary.json               # four-dataset summary and Jython caveat
analysis/                             # compact fanout/symbol evidence, analysis
                                      # source ZIP, and corrected NCU counters
FILES.json                            # payload file sizes and SHA-256 hashes
SHA256SUMS                            # sha256sum -c compatible checksums

The .csv input files are tab-delimited integer tuples, not comma-separated data. str2num.json is the complete per-dataset shared symbol dictionary; never mix dictionaries or metadata between applications. Manifests deliberately retain their preparation-only status; later engine validation is in the separate reports. Historical absolute paths in reports document the original runs and are not required installation paths.

No derived tuple exports, executables/shared libraries, compiled build caches, vendor downloads, profiler databases, unrelated workspace data, or credentials are included. Derived result sets can require tens of gigabytes and must be regenerated to rerun exact comparison.

analysis/fanout/ retains compact rule fanout and source-symbol attribution with its analysis-source ZIP. analysis/hot-rule-counters.json contains selected corrected-query Nsight Compute launches and counter summaries. These are diagnostic samples, not whole-run hardware averages; profiler-instrumented fixedpoint times are not comparable to ordinary timing runs. Large profiler traces and derived tuple files are intentionally excluded.

Download, integrity, and reproduction

Authenticate using an account granted access to this private repository, then:

hf download ysun67/srdatalog-doop-corrected-xlarge --repo-type dataset --local-dir doop-xlarge
cd doop-xlarge
sha256sum -c SHA256SUMS

Pin --revision COMMIT_SHA to the upload revision when an immutable retrieval is needed. FILES.json lists exact payload sizes and digests; SHA256SUMS also covers that manifest. The checksum file cannot hash itself.

Packaging verifies every original raw ZIP against its pinned archive size/SHA-256, fully decompresses every member to check CRC, and checks manifest-referenced raw facts by SHA-256. Every prepared relation, metadata file and dictionary is checked against its existing manifest; compressed prepared and source archives are then reopened and every file's SHA-256 checked. provenance/archive-integrity.json records the coverage. Remote upload verification is performed against revision-pinned Hub sizes and LFS SHA-256 values (and downloaded bytes for ordinary Git files); its receipt is retained with the local package.

To run, install Python 3.10+, GNU sort, Soufflé with development headers, a C++17/OpenMP compiler and zlib/SQLite development libraries for CPU, plus clang++ >=20, CUDA 12.x, and Boost container for GPU. See the bundled source/docs/getting_started.md. The source archive contains actual selected working-tree bytes; provenance/source.json gives both the checkout commit and authoritative per-file hashes. Vendored third-party dependencies are intentionally omitted and fetched by the pinned scripts/populate_vendor.py.

# Unpacks source and all four prepared inputs, then runs CPU and GPU validation.
# Requires substantial CPU RAM, disk for full exports, and an otherwise idle GPU.
# This may download build dependencies but never downloads replacement facts.
bash reproduce.sh /absolute/path/to/new-reproduction-directory

The script uses the supplied prepared inputs. To independently regenerate preparation from the raw archives, use a new root, from the unpacked source checkout:

python examples/doop_benchmark.py prepare --tier xlarge \
  --root /absolute/path/to/new-preparation-root \
  --archive-cache /absolute/path/to/doop-xlarge/raw

Reproduction commands are supplied for a suitably provisioned machine. Packaging does not rerun the expensive CPU/GPU benchmark or silently replace the retained validation evidence.