commit b14b3622f567f7532c99c11b16d894584afeea12 Author: Agila Forge Importer Date: Mon Jul 13 14:33:50 2026 +0000 Initial project import diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..98622d3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +build/ +*.o +*.ppu +*.a +*.so +*.dll +*.dylib +*.exe +.DS_Store +.idea/ +.vscode/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..a88bfaf --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,9 @@ +# Contributing + +Contributions should be small, portable, documented, and independently written for AGX Open. + +- Do not submit proprietary AGX Engine code. +- Do not include credentials, private endpoints, customer data, or internal documents. +- Add or update an example when changing a public API. +- Run `make test` before opening a pull request. +- Keep the CPU reference backend understandable for students. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..96ddbec --- /dev/null +++ b/Makefile @@ -0,0 +1,20 @@ +FPC ?= fpc +FLAGS = -Fu./src -FE./build + +all: hello compute + +build: + mkdir -p build + +hello: build + $(FPC) $(FLAGS) examples/hello_device/hello_device.pas + +compute: build + $(FPC) $(FLAGS) examples/compute_demo/compute_demo.pas + +test: all + ./build/hello_device + ./build/compute_demo + +clean: + rm -rf build diff --git a/README.md b/README.md new file mode 100644 index 0000000..5dfa289 --- /dev/null +++ b/README.md @@ -0,0 +1,41 @@ +# AGX Open + +AGX Open is the public, experimental SDK for learning and prototyping portable compute concepts in Free Pascal. + +This repository is a **clean public implementation**. It does not contain the proprietary AGX policy engine, optimization algorithms, internal scheduler, cache system, mesh enhancement system, interception layer, or commercial rendering backend. + +## Current features + +- Device and backend abstraction +- Safe buffer allocation, upload, and download +- CPU reference kernels +- CUDA-like submit-and-dispatch learning model +- Small examples that compile independently + +## Build + +Requirements: Free Pascal Compiler 3.2 or newer and `make`. + +```sh +make +make test +``` + +## Run + +```sh +./build/hello_device +./build/compute_demo +``` + +## Architecture + +Applications use the public runtime API. The included CPU backend is intentionally simple and readable. Future community backends may target Metal, Vulkan Compute, or DirectCompute without changing application code. + +## Project status + +Experimental. The API may change before version 1.0. + +## Trademark + +The license covers source code, not the AGX or Agila names, logos, or branding. See `TRADEMARKS.md`. diff --git a/RELEASE_CHECKLIST.md b/RELEASE_CHECKLIST.md new file mode 100644 index 0000000..2f4bfb4 --- /dev/null +++ b/RELEASE_CHECKLIST.md @@ -0,0 +1,9 @@ +# Public Release Checklist + +- [ ] Start from this clean directory, not the private repository history. +- [ ] Confirm no private units or internal notes are present. +- [ ] Run a secret scanner against files and Git history. +- [ ] Run `make test`. +- [ ] Confirm the copyright owner and license choice. +- [ ] Add only public screenshots, logos, and assets. +- [ ] Tag the release, for example `v0.1.0-alpha`. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..f91280a --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,5 @@ +# Security Policy + +Do not report suspected secrets or private AGX source in a public issue. Contact the repository owner privately and rotate any exposed credential immediately. + +Before every release, scan the complete Git history as well as the working tree. Deleting a file in a later commit does not remove it from earlier commits. diff --git a/TRADEMARKS.md b/TRADEMARKS.md new file mode 100644 index 0000000..1c7c80c --- /dev/null +++ b/TRADEMARKS.md @@ -0,0 +1,3 @@ +# Trademarks + +The AGX and Agila names, logos, and visual identity are not granted under the source-code license. Forks should clearly state that they are unofficial unless written permission is provided by the trademark owner. diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md new file mode 100644 index 0000000..d0a29d3 --- /dev/null +++ b/docs/ARCHITECTURE.md @@ -0,0 +1,10 @@ +# Public Architecture + +AGX Open contains only four public concepts: + +1. **Device** — selects a supported execution backend. +2. **Buffer** — stores input or output data. +3. **Kernel** — describes a user-supplied computation. +4. **Dispatch** — runs a kernel over a requested number of elements. + +The bundled reference backend executes kernels on the CPU. It exists for education, testing, and API experimentation. It does not reproduce the private AGX engine. diff --git a/docs/OPEN_CLOSED_BOUNDARY.md b/docs/OPEN_CLOSED_BOUNDARY.md new file mode 100644 index 0000000..79e74e6 --- /dev/null +++ b/docs/OPEN_CLOSED_BOUNDARY.md @@ -0,0 +1,22 @@ +# Open and Closed Boundary + +## Included in AGX Open + +- Public data types and runtime interfaces +- CPU reference implementation +- Examples, templates, tests, and documentation +- Extension points for future public backends + +## Not included + +- AGX policy and decision engine +- Hardware profiling rules +- Internal workload scheduler +- Proprietary rendering backend +- Mesh reconstruction, enhancement, optimization, validation, and LOD algorithms +- Private cache algorithms +- API interception or translation implementation +- Internal bridges and commercial integration code +- Private roadmaps and engineering notes + +Do not copy files from the private engine into this repository. New contributions must be independently written for the public SDK. diff --git a/examples/compute_demo/compute_demo.pas b/examples/compute_demo/compute_demo.pas new file mode 100644 index 0000000..f34f5e4 --- /dev/null +++ b/examples/compute_demo/compute_demo.pas @@ -0,0 +1,61 @@ +program AgxComputeDemo; + +{$mode ObjFPC}{$H+} + +uses + SysUtils, AgxOpenTypes, AgxOpenRuntime; + +const + N = 8; + +type + TFloatArray = array[0..N - 1] of Single; + +procedure VectorAdd(const Inputs, Outputs: array of TAgxBuffer; + const ElementCount: NativeUInt); +var + A, B, C: TFloatArray; + I: NativeUInt; +begin + Inputs[0].Download(@A[0], ElementCount * SizeOf(Single)); + Inputs[1].Download(@B[0], ElementCount * SizeOf(Single)); + for I := 0 to ElementCount - 1 do + C[I] := A[I] + B[I]; + Outputs[0].Upload(@C[0], ElementCount * SizeOf(Single)); +end; + +var + Device: TAgxDevice; + ABuffer, BBuffer, CBuffer: TAgxBuffer; + Kernel: TAgxKernel; + A, B, C: TFloatArray; + I: Integer; +begin + for I := 0 to N - 1 do + begin + A[I] := I; + B[I] := I * 10; + end; + + Device := TAgxDevice.Create; + ABuffer := nil; BBuffer := nil; CBuffer := nil; Kernel := nil; + try + Device.CreateBuffer(SizeOf(A), agxBufferStorage, ABuffer); + Device.CreateBuffer(SizeOf(B), agxBufferStorage, BBuffer); + Device.CreateBuffer(SizeOf(C), agxBufferStorage, CBuffer); + ABuffer.Upload(@A[0], SizeOf(A)); + BBuffer.Upload(@B[0], SizeOf(B)); + Device.CreateCPUKernel('vector_add', @VectorAdd, Kernel); + Kernel.Dispatch([ABuffer, BBuffer], [CBuffer], N); + CBuffer.Download(@C[0], SizeOf(C)); + + for I := 0 to N - 1 do + WriteLn(Format('%0.0f + %0.0f = %0.0f', [A[I], B[I], C[I]])); + finally + Kernel.Free; + CBuffer.Free; + BBuffer.Free; + ABuffer.Free; + Device.Free; + end; +end. diff --git a/examples/hello_device/hello_device.pas b/examples/hello_device/hello_device.pas new file mode 100644 index 0000000..dfeaa37 --- /dev/null +++ b/examples/hello_device/hello_device.pas @@ -0,0 +1,19 @@ +program HelloAgxDevice; + +{$mode ObjFPC}{$H+} + +uses + AgxOpenTypes, AgxOpenRuntime; + +var + Device: TAgxDevice; +begin + Device := TAgxDevice.Create; + try + WriteLn('Device: ', Device.Info.Name); + WriteLn('Backend: ', AgxBackendName(Device.Info.Backend)); + WriteLn('Compute: ', Device.Info.SupportsCompute); + finally + Device.Free; + end; +end. diff --git a/src/AgxOpenRuntime.pas b/src/AgxOpenRuntime.pas new file mode 100644 index 0000000..818fdca --- /dev/null +++ b/src/AgxOpenRuntime.pas @@ -0,0 +1,145 @@ +unit AgxOpenRuntime; + +{$mode ObjFPC}{$H+} + +interface + +uses + Classes, SysUtils, AgxOpenTypes; + +type + TAgxDevice = class; + + TAgxBuffer = class + private + FData: TBytes; + FUsage: TAgxBufferUsage; + public + constructor Create(const ASize: NativeUInt; const AUsage: TAgxBufferUsage); + function Upload(const Source: Pointer; const Size: NativeUInt; const Offset: NativeUInt = 0): TAgxResult; + function Download(Destination: Pointer; const Size: NativeUInt; const Offset: NativeUInt = 0): TAgxResult; + function Size: NativeUInt; + property Usage: TAgxBufferUsage read FUsage; + end; + + TAgxKernelProc = procedure(const InputBuffers, OutputBuffers: array of TAgxBuffer; + const ElementCount: NativeUInt); + + TAgxKernel = class + private + FName: string; + FProc: TAgxKernelProc; + public + constructor Create(const AName: string; const AProc: TAgxKernelProc); + function Dispatch(const Inputs, Outputs: array of TAgxBuffer; + const ElementCount: NativeUInt): TAgxResult; + property Name: string read FName; + end; + + TAgxDevice = class + private + FInfo: TAgxDeviceInfo; + public + constructor Create(const RequestedBackend: TAgxBackend = agxBackendAuto); + function CreateBuffer(const Size: NativeUInt; const Usage: TAgxBufferUsage; + out Buffer: TAgxBuffer): TAgxResult; + function CreateCPUKernel(const Name: string; const KernelProc: TAgxKernelProc; + out Kernel: TAgxKernel): TAgxResult; + property Info: TAgxDeviceInfo read FInfo; + end; + +function AgxBackendName(const Backend: TAgxBackend): string; + +implementation + +constructor TAgxBuffer.Create(const ASize: NativeUInt; const AUsage: TAgxBufferUsage); +begin + inherited Create; + SetLength(FData, ASize); + FUsage := AUsage; +end; + +function TAgxBuffer.Upload(const Source: Pointer; const Size, Offset: NativeUInt): TAgxResult; +begin + if (Source = nil) or (Offset + Size > NativeUInt(Length(FData))) then + Exit(agxErrorInvalidArgument); + Move(Source^, FData[Offset], Size); + Result := agxSuccess; +end; + +function TAgxBuffer.Download(Destination: Pointer; const Size, Offset: NativeUInt): TAgxResult; +begin + if (Destination = nil) or (Offset + Size > NativeUInt(Length(FData))) then + Exit(agxErrorInvalidArgument); + Move(FData[Offset], Destination^, Size); + Result := agxSuccess; +end; + +function TAgxBuffer.Size: NativeUInt; +begin + Result := Length(FData); +end; + +constructor TAgxKernel.Create(const AName: string; const AProc: TAgxKernelProc); +begin + inherited Create; + FName := AName; + FProc := AProc; +end; + +function TAgxKernel.Dispatch(const Inputs, Outputs: array of TAgxBuffer; + const ElementCount: NativeUInt): TAgxResult; +begin + if not Assigned(FProc) then + Exit(agxErrorInvalidArgument); + FProc(Inputs, Outputs, ElementCount); + Result := agxSuccess; +end; + +constructor TAgxDevice.Create(const RequestedBackend: TAgxBackend); +begin + inherited Create; + FInfo.Name := 'AGX Open CPU Reference Device'; + FInfo.Backend := agxBackendCPU; + FInfo.SupportsCompute := True; + FInfo.MaxWorkgroupSize := 1; +end; + +function TAgxDevice.CreateBuffer(const Size: NativeUInt; const Usage: TAgxBufferUsage; + out Buffer: TAgxBuffer): TAgxResult; +begin + Buffer := nil; + if Size = 0 then + Exit(agxErrorInvalidArgument); + try + Buffer := TAgxBuffer.Create(Size, Usage); + Result := agxSuccess; + except + Result := agxErrorOutOfMemory; + end; +end; + +function TAgxDevice.CreateCPUKernel(const Name: string; const KernelProc: TAgxKernelProc; + out Kernel: TAgxKernel): TAgxResult; +begin + Kernel := nil; + if (Name = '') or not Assigned(KernelProc) then + Exit(agxErrorInvalidArgument); + Kernel := TAgxKernel.Create(Name, KernelProc); + Result := agxSuccess; +end; + +function AgxBackendName(const Backend: TAgxBackend): string; +begin + case Backend of + agxBackendAuto: Result := 'Auto'; + agxBackendCPU: Result := 'CPU'; + agxBackendMetal: Result := 'Metal'; + agxBackendVulkan: Result := 'Vulkan'; + agxBackendDirectCompute: Result := 'DirectCompute'; + else + Result := 'Unknown'; + end; +end; + +end. diff --git a/src/AgxOpenTypes.pas b/src/AgxOpenTypes.pas new file mode 100644 index 0000000..8e2ebf5 --- /dev/null +++ b/src/AgxOpenTypes.pas @@ -0,0 +1,41 @@ +unit AgxOpenTypes; + +{$mode ObjFPC}{$H+} + +interface + +type + TAgxResult = ( + agxSuccess, + agxErrorInvalidArgument, + agxErrorNotInitialized, + agxErrorUnsupported, + agxErrorOutOfMemory, + agxErrorBackend + ); + + TAgxBackend = ( + agxBackendAuto, + agxBackendCPU, + agxBackendMetal, + agxBackendVulkan, + agxBackendDirectCompute + ); + + TAgxBufferUsage = ( + agxBufferStorage, + agxBufferVertex, + agxBufferIndex, + agxBufferUniform + ); + + TAgxDeviceInfo = record + Name: string; + Backend: TAgxBackend; + SupportsCompute: Boolean; + MaxWorkgroupSize: LongWord; + end; + +implementation + +end. diff --git a/templates/basic_project/src/main.pas b/templates/basic_project/src/main.pas new file mode 100644 index 0000000..68e54b8 --- /dev/null +++ b/templates/basic_project/src/main.pas @@ -0,0 +1,17 @@ +program MyAgxProject; + +{$mode ObjFPC}{$H+} + +uses + AgxOpenRuntime; + +var + Device: TAgxDevice; +begin + Device := TAgxDevice.Create; + try + WriteLn('AGX Open project is ready on ', Device.Info.Name); + finally + Device.Free; + end; +end. diff --git a/tests/smoke_test.sh b/tests/smoke_test.sh new file mode 100644 index 0000000..bd81944 --- /dev/null +++ b/tests/smoke_test.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +make clean +make test