diff --git a/.gitattributes b/.gitattributes index a3625e835a08c30544be7fb62526e17cfbdf9c82..06d9159c1a920e8853a65770ae804529745ee0e6 100644 --- a/.gitattributes +++ b/.gitattributes @@ -246,3 +246,21 @@ build/torch213-cxx11-cu132-x86_64-linux/_tinygrad_rms_cuda_89d4054.abi3.so filte build/torch214-cxx11-cu126-x86_64-linux/_tinygrad_rms_cuda_89d4054.abi3.so filter=lfs diff=lfs merge=lfs -text build/torch214-cxx11-cu130-x86_64-linux/_tinygrad_rms_cuda_89d4054.abi3.so filter=lfs diff=lfs merge=lfs -text build/torch214-cxx11-cu132-x86_64-linux/_tinygrad_rms_cuda_89d4054.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch212-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch212-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch212-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch213-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch213-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch213-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch214-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch214-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch214-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch215-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch215-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch215-cu134-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so filter=lfs diff=lfs merge=lfs -text diff --git a/build/torch210-cu126-aarch64-linux/__init__.py b/build/torch210-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch210-cu126-aarch64-linux/_ops.py b/build/torch210-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch210-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch210-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..03c4c98b5f17d8ced4079ed02edb613d6c38b61a --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab5f5020f28517ede32795da544d9d3299ddffbf82dc6c9da179a09632cc0db0 +size 295984 diff --git a/build/torch210-cu126-aarch64-linux/metadata.json b/build/torch210-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bcc21f09ac3c1649b7a039a0315750eef6c2e5fd --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/metadata.json @@ -0,0 +1,42 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "q19QIPKFF+3jJ5XaVE2dMpnd/7+C3GydoXmgljLMDbA=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch210-cu126-aarch64-linux/metadata.json.sigstore b/build/torch210-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..7fa425efff0703cb1f8ea20198417cfa9f747f77 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"MIIHLTCCBrKgAwIBAgIUA9NiKjEQtJt4QVj3g4nTFVZeVR8wCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjYxMDE5MTI1NjQ3WhcNMjYxMDE5MTMwNjQ3WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJa9SwmAs5kSkNJ9bz3x7zcyT0hDWM8kJv2lB9UjeTgKs1YqnDDrmSGjG5/7Zmbf60rxweu73xLSvm71MTi02gaOCBdEwggXNMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAfBgNVHSMEGDAWgBTf0+nPViQRlvmo2OkoVaLGLhhkPzBrBgNVHREBAf8EYTBfhl1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50LmNvbTAfBgorBgEEAYO/MAECBBF3b3JrZmxvd19kaXNwYXRjaDA2BgorBgEEAYO/MAEDBChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBMGCisGAQQBg78wAQQEBUJ1aWxkMCsGCisGAQQBg78wAQUEHWh1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5MB0GCisGAQQBg78wAQYED3JlZnMvaGVhZHMvbWFpbjA7BgorBgEEAYO/MAEIBC0MK2h0dHBzOi8vdG9rZW4uYWN0aW9ucy5naXRodWJ1c2VyY29udGVudC5jb20wbQYKKwYBBAGDvzABCQRfDF1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOAYKKwYBBAGDvzABCgQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBsGCisGAQQBg78wAQsEDQwLc2VsZi1ob3N0ZWQwQAYKKwYBBAGDvzABDAQyDDBodHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkwOAYKKwYBBAGDvzABDQQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMB8GCisGAQQBg78wAQ4EEQwPcmVmcy9oZWFkcy9tYWluMBoGCisGAQQBg78wAQ8EDAwKMTA3MTQ3NTUyOTAuBgorBgEEAYO/MAEQBCAMHmh0dHBzOi8vZ2l0aHViLmNvbS9odWdnaW5nZmFjZTAYBgorBgEEAYO/MAERBAoMCDI1NzIwNzQzMG0GCisGAQQBg78wARIEXwxdaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5Ly5naXRodWIvd29ya2Zsb3dzL2J1aWxkLnlhbWxAcmVmcy9oZWFkcy9tYWluMDgGCisGAQQBg78wARMEKgwoZmUyYmI2NmZlZTZjMmE3N2VjY2YwOGEwNTA4ZGM1NzQyOGQ0ODhlZDAhBgorBgEEAYO/MAEUBBMMEXdvcmtmbG93X2Rpc3BhdGNoMGQGCisGAQQBg78wARUEVgxUaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5L2FjdGlvbnMvcnVucy8zOTIzOTY3MjY5MS9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwGcHVibGljMEYGCisGAQQBg78wARgEOAw2cmVwbzpodWdnaW5nZmFjZS9rZXJuZWxzLWNvbW11bml0eTpyZWY6cmVmcy9oZWFkcy9tYWluMIGKBgorBgEEAdZ5AgQCBHwEegB4AHYA3T0wasbHETJjGR4cmWc3AqJKXrjePK3/h4pygC8p7o4AAAGhVDxoIQAABAMARzBFAiEAu5ZIiXZcDN8lAuCU4Erj2T2VkOKlWV8BjR5LHLR+k3oCIDq4IyvJEi4RU2Vjsno5EFHTrFNtZAQG1N0N7q5aMdS8MAoGCCqGSM49BAMDA2kAMGYCMQDal8Naxix5jkdETlrXCfmfJHzPgYtLFKO2pbkiWm1Eyd9X8vWq9uPpmViJ4drjQtMCMQCOD3xOBFNKOKlXy9EhNEmYyfPtyfFrO1unD80jf1lZN2bQtmanpDx7kT2lopMFYBU="},"tlogEntries":[{"logIndex":"3321160982","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414607","inclusionPromise":{"signedEntryTimestamp":"MEUCICaS3NSlkyD1V41ikJCl+5ooauDf4Ha29iyszm8MHBhfAiEAl9HWS8vOucehDPnCotLZZrth6xppAfYT61LqeGe+hRI="},"inclusionProof":{"logIndex":"3199256720","rootHash":"0Z4QmgmC3aaPKROEpxxopl0NKQSiZbWoKbThfqiVZ/k=","treeSize":"3199256901","hashes":["s/irtEEBpnmXBXzkEOhHjQEXr5qHLTZF7ptyomud3Xw=","Uq1WxT1xUbkMHSxRB/VL/HE3/Yip5pW+GBFGaKCrD4w=","KZaA8VuomRyv2IMe3LX2jWuTU2WhcysEv/ZH+keIfbg=","ynFj9XV5v4XJI/65LbNoZlXnvz4AdxUJuB4s34xwCME=","rmbriZOyyxkgnjrSuRuMY+YUDmXoiQyubmqly88qphs=","Lvi96QEAy25HoRRdemgeMGiHs9twjH+zi20s/eV0ZG8=","xdgYLDSUFmu1z2zWB/XEpHbCx+LU5U158D6n0AEoSOs=","FmUiijlL+ubLS3/DOK2DWovxKogabgiZihnrs5uaDCk=","uBaxDTknqmHU0ZizbMUrMR/xrscELkTfe6v29Xzwras=","RDiptQkgvHMCbbkUY0uCBCHKvOHg1Ua2eiSp9YCjEBw=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199256901\n0Z4QmgmC3aaPKROEpxxopl0NKQSiZbWoKbThfqiVZ/k=\n\n— rekor.sigstore.dev wNI9ajBGAiEAjudRdyP7DEOC9CHGr2KRIOF2RQB9eF/dRAlqdAnh9M8CIQCTFPTRzx75yB3FAemighVGgMB9mVfG/lWdXpiiqnawzQ==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgFMVpMFTTsicpG2y+hXn2Z9VIW9C0MZndcpS/dbAxuVECFQDDuPcfQMch74tOxj9e1KmPN0goGRgPMjAyNjEwMTkxMjU2NDdaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTY0N1owLwYJKoZIhvcNAQkEMSIEIDdn0a7NHDNDcOdlxqgti1ETa/IaK7Zw5n1Y1y0QHHheMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMCUORnrIFg7tNQWGTnsPHQgZ+uV6KGsPwXgGfkQda04msxy6FV3sG7wTr7WcndMSPQIxAIhT3PdsMbkrTwxrlU7X539HEwORmcClOBIpWq3PbLkeRrf/i0ODk5JSN/0Tcdz5pA=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"5UZi0ckdAqmCzd7dcbzvm+6afRYT6KUfWvfJmPwbNW8="},"signature":"MEYCIQDKzsPvF/SaCf8fKjHUTRYqW/oidGUeRgkovBej4dHd7wIhANiF/S5TGFI+MA+qE6u98ojUKVNZa0tszmvA6gwF4IQt"}} \ No newline at end of file diff --git a/build/torch210-cu126-aarch64-linux/symbols.json b/build/torch210-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch210-cu128-aarch64-linux/__init__.py b/build/torch210-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch210-cu128-aarch64-linux/_ops.py b/build/torch210-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch210-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch210-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..39bf86de887750b9709c3b53abd7a05714a1b629 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ece3769c7079e0bcbd35ee2bb645d4298830fa9fcd016ce0c4fed26767ecd9a +size 361800 diff --git a/build/torch210-cu128-aarch64-linux/metadata.json b/build/torch210-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bd1c50aa6b44107013588423c398e43e6c2f3a5c --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "js43accHngvL017iu2RdQpiDD6n80BbODE/tJnZ+zZo=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch210-cu128-aarch64-linux/metadata.json.sigstore b/build/torch210-cu128-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..eb822670494ef825f35b47a5513d2deb6a5e4ee8 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321161443","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414610","inclusionPromise":{"signedEntryTimestamp":"MEUCIQCBp+EFPM+1PPl/EjkcveZwC1vSfa1+Peu9UjWyPBfggwIgErjFyeAbIvbS63hnZWCJGrs3qoHmvRK4UeF2YUvmPtU="},"inclusionProof":{"logIndex":"3199257181","rootHash":"ryt8i9sqnJzYYxDwkld4bWb4HHvAY6hVWw6OARtAiu0=","treeSize":"3199257842","hashes":["tPldtYTSRV8lrNMi18nSPDLG+5LdegHPU3colvrXgEw=","Z19I0PPu8/YjsUKhrKwabxV1YMyCSmt1kT0c5IJzDP0=","ibd8NytOxvUgSypwdHVlo0TOa153xGq8DtBottqE6is=","ckkVxiUfPGnQLiaN4wzd5vaoDHpW+FEFV3DafmjzN0M=","XJOWKy+FJOynifmtocabbLqWZr6RS82fjqb/gbKbMps=","Zyu+2m/rP42YLM0dXWviVHgPee/q3adFH3/TJSD5dJY=","4PtjbBBn2Z+A67bTzYPpgntfMBC2Fx5/Lu6kYAgCQCA=","1bKJeEJQ4bJ6H5mXUoWlNOw2KCglbwr5T8xdy5TZp7Y=","dBTc3Z/13SmgUPvECf03MK1tDEK365h26o58LomeBdU=","zyjl4sBdQrJDu36+pmFFFtJxy8lqAaZuV8ekxCzIzaI=","CQiaRElcjBjA/BA17GZbdPURQvrfI38qcHGX4kkccUI=","RDiptQkgvHMCbbkUY0uCBCHKvOHg1Ua2eiSp9YCjEBw=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199257842\nryt8i9sqnJzYYxDwkld4bWb4HHvAY6hVWw6OARtAiu0=\n\n— rekor.sigstore.dev wNI9ajBFAiEAkv8QtcCFESDLKYTKUUPKary4i28j3pi/tketU4tyL38CICewnJdVjVmjFuIUpyl5vLgAJHBS7gFM5+v3ksSvn0Ts\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgyaHkdlZ6nn9SKp+JB8gT9HbL+1scWqGIAB5wCfRq5mYCFQCQ7v8+ATQKCYkYpRf6UULFbbNikhgPMjAyNjEwMTkxMjU2NDlaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTY0OVowLwYJKoZIhvcNAQkEMSIEIN2xZ5x1RLW+3Bdwrhg+4DqwIbXx8vErQm6nYasIZRPiMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMGN57OJkSMfdW+b4NIWXS88rlFn/vjv/1yKYT0vB++8AtifCSEyOqYpXzS+3QHeOtAIxAI92qw7EPC0FT0hZUJvQ9fPtMwCEFTalUF74C6Jes2D2hRt7fxUsKh2znkDLrM049g=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"eFM32lvfC3wPIT1VYhHFgVghAng5e5GfFOaYECAWyXw="},"signature":"MEUCIDrymLZKOQZI6+WYvz5R21QPUbxdy3oNmDFTL5cPpNYfAiEAqrgvD4bmEAKLtHZmfZ+sc8q881rr4fMn53WGyE+t4vc="}} \ No newline at end of file diff --git a/build/torch210-cu128-aarch64-linux/symbols.json b/build/torch210-cu128-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch210-cu130-aarch64-linux/__init__.py b/build/torch210-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch210-cu130-aarch64-linux/_ops.py b/build/torch210-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch210-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch210-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..fff6b37f9acb0ad0f43225f860b14ceecef808aa --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:09fa39477bb9af4508b9adef8ad7dcdb949d993bcc12a3fd676de2e02d701ff3 +size 429424 diff --git a/build/torch210-cu130-aarch64-linux/metadata.json b/build/torch210-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9f4e3fd6b7f6a3a0dc65e132da4a12be34209d5a --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "Cfo5R3u5r0UIua3vitfc25SdmTvMEqP9Z23i4C1wH/M=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch210-cu130-aarch64-linux/metadata.json.sigstore b/build/torch210-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..de4eab0004f8a196e1c227e2ddc96dea65b431bc --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321162402","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414614","inclusionPromise":{"signedEntryTimestamp":"MEUCIESe0TBXZaW9uJXYe6IhPTM9mttf5gDJEY/OtCbZnBoMAiEAzPwK7PZNFQxx/yUBdsOLUPmtWQC5iMjkR4PYlpg6zHs="},"inclusionProof":{"logIndex":"3199258140","rootHash":"JnqkvEaNcj0lM1lzpUT7K6npJqBWVPC7Tuj87olo0PU=","treeSize":"3199258207","hashes":["VAMIEmc3OI1o5fEBTKGiBelPyFByXfsd6igMEcXl0Hs=","ym+j2RUHDOKHR4+g7J6LdKYnq5ZbjziMIRA0VDMqU8Q=","n0qBxdjhWD6mvQxYewnLoz9G29WQP2sjX+6hD9pWw20=","fmxWA9q+YcUF7uIHVgKwov6Ad70+C6NecUmdpl/eARc=","K+ANH+kOXiwuN0R7CdrJrywxv2oAffd0pP9m6oHO7GI=","UZDQF5fpHrZQ1ibu2vBkwQWPiQ94cHuvJ7eH5XYdRDo=","IdwGTyHooGZvIrw/WI4elPV3Zg24nLrG/xfTZVPVpQ0=","O8nkgOfH0ApJpxKNTSbOxmIjQD2rM0J/mgkNy8uscu0=","xdttCxFvihb/TPSLyQhxrLHPiy2Hoto30MGgSbTHHxo=","RDiptQkgvHMCbbkUY0uCBCHKvOHg1Ua2eiSp9YCjEBw=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199258207\nJnqkvEaNcj0lM1lzpUT7K6npJqBWVPC7Tuj87olo0PU=\n\n— rekor.sigstore.dev wNI9ajBFAiEA6MY+K0gAp0dI2zuPmRzBl/khdaLe/8Xuzjyl5UAJBsMCIHkCnEQOR86Rbkodw+2aeOmIPYXvD3R/7tcygrtpRNNM\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg6xID5Qo6XKZ8I9MnBt+YhrwietD2t2lD5n9mgVoyEgoCFHilIiIdBOwNKRZiiWhi6XHMh7m2GA8yMDI2MTAxOTEyNTY1NFowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdwwggHYAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1NjU0WjAvBgkqhkiG9w0BCQQxIgQgssgBmvKg/TlzRMGLs8PBh2vYAAO+5vuEeN1SaUxZFbAwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGgwZgIxAL5Dhj5GEcZ9HRlTYt1HBGne33na7oPtlilMNt52K9RmHdnypCG9yNoY7pXp6H6ZQgIxANwnopI3uYNBGJO2HcPXRiqutlhjJjrx64/8+PcykhzDxRXoByB4X56P4UaNiLyxfw=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"9WV575VH6cdf0PlZfFBACWJL1SPgxmggknI+5H0MAdw="},"signature":"MEQCIDtLo05g2qwHoija8/odggmpGanZwJuUuIB5Rwq5C3v1AiBzD91X6sb9GzaclA+zNYUF9X7DGo+2QGPRx1ua5bDgCQ=="}} \ No newline at end of file diff --git a/build/torch210-cu130-aarch64-linux/symbols.json b/build/torch210-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch211-cu126-aarch64-linux/__init__.py b/build/torch211-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch211-cu126-aarch64-linux/_ops.py b/build/torch211-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch211-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch211-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..4f6c80ee371e5222d91a8324c2990bbab0839943 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad45fe2b08bc5c0b0ac39ea32835454f752c8155ae05202c04784325de362bf7 +size 292224 diff --git a/build/torch211-cu126-aarch64-linux/metadata.json b/build/torch211-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..efeed79ae788f4cc0a4779c9a76012f4ca15bd6f --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/metadata.json @@ -0,0 +1,42 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "rUX+Kwi8XAsKw56jKDVFT3UsgVWuBSAsBHhDJd42K/c=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch211-cu126-aarch64-linux/metadata.json.sigstore b/build/torch211-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..5f109e0203d5cd9249df150568ca676bd6f02f44 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321163183","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414619","inclusionPromise":{"signedEntryTimestamp":"MEUCIQCDUR9mm5r4gqxne9MobhZtxhxpFhrVzIBtUwJ0CNvTXwIgdQoqBCbTRWLW1yw0tvbegkVwl81IeuIKWzarLGgFO1E="},"inclusionProof":{"logIndex":"3199258921","rootHash":"VMByCZRHlOb+XdU6yGtd4RnUDi7MHktD0mlKf1boXxw=","treeSize":"3199259458","hashes":["L5bVEGNcMFAAvNVhooLKBaeJhkjHDES2t0n2WVd7tOo=","5iE6DvXu1mbXo8fdxl9L0/msipEdJRew65v2xVR3S2k=","a7AMFA263YpfoEv/bonT+QlNloQS04vECl9bdSGQz2w=","4/54eXfW2iZUqADlN6BDGVwFHpF4T57nqw2aJy4GOx4=","cRXI03wPtDlFyPPiQ14lXxMovXYn9pe9itTt+IRZcTE=","MUtaSG4e3IcEun2dzTKu2MFdO3YlLXKrGaC7PLsju/s=","/y92RYtKG2xFdQo3WBQYId0DKtyzLxACKJk2wIEU/Xw=","Dt8gUtXOgnm77h3JRUDSSK9DzOdCqdSo40rFcdVQTVw=","ROAD3rhw9TDHOZf9nosKdyTqgU+H5jPQha/dpr9qAok=","+w44Jvf0ZIYBHBZPCsgXVUfIEWxlfVU6BiqNzWjqa9E=","0ncMyp4Jfu28TPBIYf4+3b3Wu5vq61YSK18oAeQbz/k=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199259458\nVMByCZRHlOb+XdU6yGtd4RnUDi7MHktD0mlKf1boXxw=\n\n— rekor.sigstore.dev wNI9ajBGAiEA+a4yjuPYDOs4nzTSjmTqJXVH3l4UF9tTfHEPSsZ4NWYCIQCCW9XIL+7RKT5RdduoKlEueSJ2DXNIZOarzPYROwZ7Sg==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyzADAgEAMIICwgYJKoZIhvcNAQcCoIICszCCAq8CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgG2re74diokIK/Rkdanmd3AYQD00Ih2pz/IQQ4BzRXQUCFQD7k/YIxuDJKFWRG8QIjsbHgr5s2RgPMjAyNjEwMTkxMjU2NThaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHcMIIB2AIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTY1OFowLwYJKoZIhvcNAQkEMSIEIAUUK0pDbruiqgz8M6LhnNF5TLXCwEUCAM2UzgBYKNYdMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRoMGYCMQDJMXPVnnwuf664gpsipWiRA+/iquDjgdDQVd2mTcU4COk0w61qX1iIWwodmlV8VJACMQCpUYUw32HrcYhQOhaFGGWYfKIcxvQcQ4Id9l49b3dJJzoFM42MeqlitVINpeMfpkI="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"HKfFmVpBOxrTGGTbnXpNSK/NkncgZo31ly2JeEMjHos="},"signature":"MEQCICUL4IHZW2Ki2XfZzdRMFABW3fXvg8ent7iiffQoW3lrAiBWtpCemAl4FrNdJUeHFctVVLXQUarjhf3Zluy1631j0w=="}} \ No newline at end of file diff --git a/build/torch211-cu126-aarch64-linux/symbols.json b/build/torch211-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch211-cu128-aarch64-linux/__init__.py b/build/torch211-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch211-cu128-aarch64-linux/_ops.py b/build/torch211-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch211-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch211-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..61eb22317e80bb93d905a040f31b5d8144042542 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:faaadf9ce9388a7328e6576d391b207dc8e39ee72cff8036248527cb4d49382a +size 358048 diff --git a/build/torch211-cu128-aarch64-linux/metadata.json b/build/torch211-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..193ea5e14c049f7434ca8e355f31001dc1576295 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "+qrfnOk4inMo5ldtORsgfcjjnucs/4A2JIUny01JOCo=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch211-cu128-aarch64-linux/metadata.json.sigstore b/build/torch211-cu128-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..296f960dd5cd72c044965d5875fb980867ccd900 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321164274","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414624","inclusionPromise":{"signedEntryTimestamp":"MEYCIQDQ+dzdBHbSY0emi2FifJH03bMSIGImRNPqLaR5ktYUSwIhAPSIDHqFh8KVlE/C97CuvCCDRJfIxBQuwmK32Lr+8NYn"},"inclusionProof":{"logIndex":"3199260012","rootHash":"Z0u5J1/dB+/pMC1lS1ndF1QN2qKeGLExvhEK8poGn5I=","treeSize":"3199261044","hashes":["dMGuDMrtPnOMAdhIi1a2aemSa8miSjI4MlXwBgO9KTI=","lHmxB7kJhawKcTuVLxlxK6PEJMFX9m2Pgdbki5K5PAE=","P1SfLvnmfBZBgICua9RA3IffQuXi82jzy4HKx58yCJ0=","jh3BDKs1Qr0Vkc5mIWXaLJ5t2QFY35XLdVRWiTb9HNA=","45dzbDgygvwyf1LcOv8AzROkih0/S9r+RZxiaKFKOBc=","zD1lutvThZYWF8ajexDhxnUbn8j9yMbBpGA5PDPRpiI=","ziA90h3hM9UHnyCVAKJOcvcbWvO+pHxSm61J7XNPZyo=","fpYgc0mMdI+hSZIlw3j3q/kayVl5wY27vJPSMiyQvog=","rygmVBb5kmndv+ek7tm/siq2feFcaQfqnqYOKURo7RU=","b5yHpSC4iGMV9L5o+pSr0fO85PgBA9T9FKm/LJIzknE=","gnPWVqsjyBGaKVqE7PTC5Q4hNMGUjfvAobZrrWsVvI0=","NpgN7Y2HAbDZLd1cDA1F4fcLdQnv8nvn3JPBkFGSH3c=","0ncMyp4Jfu28TPBIYf4+3b3Wu5vq61YSK18oAeQbz/k=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199261044\nZ0u5J1/dB+/pMC1lS1ndF1QN2qKeGLExvhEK8poGn5I=\n\n— rekor.sigstore.dev wNI9ajBGAiEA0TkxvWTrimfusXPhjCLS28hEQlUkjPdBxsDYKxN7gwMCIQCNOWlqjGeFz3VKy6Qn32QolmQ2yypGdoX5HzQahrekww==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgGskgVpCYObaBBgnp0blRzMjbgeO3V9kfaSz8YFdD6vwCFQCNmVvjmWOfK1denbvaR70FnDBOWxgPMjAyNjEwMTkxMjU3MDJaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTcwMlowLwYJKoZIhvcNAQkEMSIEICj+OBV6JmVB5bpnxheO7CqSsQAoc/3+IAEYO72yfW5+MIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMQCNWRdUDFiCZcpqZIl6T6ouBA53EKCFYBsSdv4ITPLeC5phM/H8hS9kqnBnj0CFAXUCMBxrCse2vGFnearlCkkwm2YzjE8H5t6JXwFxlyATdCqkwCuStVI9hnR+vdjRgjzBYQ=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"HLQ9HnPTqb8Xdw7wO6Bh+JMC/oC2NO4qn2KFRf8edKQ="},"signature":"MEYCIQD8Hcp8KYAeirUHRFmUlJPzJxL4lJG3ksw0Vtai1zEylwIhAIolYF3qEeKzl/Y0hl2NumfEVsUVVVj4+HGSzNMegSPr"}} \ No newline at end of file diff --git a/build/torch211-cu128-aarch64-linux/symbols.json b/build/torch211-cu128-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch211-cu130-aarch64-linux/__init__.py b/build/torch211-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch211-cu130-aarch64-linux/_ops.py b/build/torch211-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch211-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch211-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..318cfc77e3dba328fe73a4d2d757f9729b24b0d6 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:978373f5e08fecff754b5397c697182e120160c641ee516118f4e27058e6a43b +size 360128 diff --git a/build/torch211-cu130-aarch64-linux/metadata.json b/build/torch211-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..03a4d412f0f64eade7350444ce72e7ef9311910f --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "l4Nz9eCP7P91S1OXxpcYLhIBYMZB7lFhGPTicFjmpDs=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch211-cu130-aarch64-linux/metadata.json.sigstore b/build/torch211-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..9853b91c58ed42604698b6d7366681e9b8af4b22 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321165500","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414631","inclusionPromise":{"signedEntryTimestamp":"MEUCIDFTkCff0XVhDupIC55T4BqXrPPefzxK0a/Tvqcz5XmWAiEAhxOccC9WsqnuZNy5hVI7j64iyKUwK4DGiNZImufRH6I="},"inclusionProof":{"logIndex":"3199261238","rootHash":"qIe/Sr2xOixZrjC7B5UTf/SG4cdzHiZ4LmEHesJsftg=","treeSize":"3199261517","hashes":["ngf67HwpPr2Zqf9R52dNozOMM+RtYmSuXK+lIazVK9c=","WEVRgdB9aJh7mR0gFJcAbgwc5gnM8wzObPEJ8nBd1Hk=","fF6dco8BIEXwu4A235SXoR0XJ8wB7gIlIkL9+YiRxZI=","ppPs5k0ArgnVI2f5hBMCmX6buHp0n73Gxf+mqRQHahg=","uSgrsJQpV6qoaz950RP2pizC75GwiAcWAnZwJYTJHf0=","R3DOgwTtUr5mdXSKrJmgqveyEVJdIAAfm+Jswb1e30A=","Y+jkJILZ7t6vQP1YIXyjXg4rfpkT0qiElJlu5aFIwRs=","YhNs0Rje2mx/IYG4nAKVxC6m4vLCFWB74vNgLzAjgV8=","Hk2qtYT+pyNWmBmGbAXhe9/crjC7X5s8XvyzUoTep+g=","aZjcG+V1T7oWJPWWBSQKyoaInzAml6JU0W/+E5j+Hfc=","D1jVFYPN8ehYQ5loUdTL/u1gey9bm+6KTC6zQuNjguE=","0ncMyp4Jfu28TPBIYf4+3b3Wu5vq61YSK18oAeQbz/k=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199261517\nqIe/Sr2xOixZrjC7B5UTf/SG4cdzHiZ4LmEHesJsftg=\n\n— rekor.sigstore.dev wNI9ajBGAiEAqGavvcAHAqaPGcAgIVrxquIfvy0fS9KZaTFjgO5RwmACIQDnzVoRStjD6rltXL2+dAszyIXES1MROT+uAUoKubFonA==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg/0530eKNl1xSfvCKK38tONvfEmF9Iscuvbty3Cd8ycgCFQDothSwkr0g0WSc7HaTiwToZIy6JRgPMjAyNjEwMTkxMjU3MTBaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTcxMFowLwYJKoZIhvcNAQkEMSIEIEVz3Ed5Zd8Hmdh/XJt6iPdndfjuEh7od6ew9HvtY3aIMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMHBgtP7JCFzut5uSDTZZDIbvAXw56xKGwK8LWE3XYP765aGS1fC8aVQj2lLftPDHjQIwMTCVoT1IBIcBQ8U1eIc5KMkOptPbcr5h/LBShdL0lzWQjHFT29KsXhiBVykifxD4"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"5XUlWYzW05sbz23c5Mg2+no9dr9SROEyiBqWar/6zXg="},"signature":"MEQCIHxMARh3U8Y8Xn3XvhVHMr6T/a+bECqG34rRSaxKn+WvAiB3J4RERUOQ4F5tjjWw57bNL4VKQW08nhZCpwtw5r6xDw=="}} \ No newline at end of file diff --git a/build/torch211-cu130-aarch64-linux/symbols.json b/build/torch211-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch212-cu126-aarch64-linux/__init__.py b/build/torch212-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch212-cu126-aarch64-linux/_ops.py b/build/torch212-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch212-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch212-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..bed42a8d16482347f19b705d51cbb0ff78f07339 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0fe63677560d6d5e07798f880a5cc3be47f1a0a3a6259c03ced6d65d91de7df0 +size 294736 diff --git a/build/torch212-cu126-aarch64-linux/metadata.json b/build/torch212-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..935399c3400e12e115589ecf1e76c6b71afd87c9 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/metadata.json @@ -0,0 +1,42 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "D+Y2d1YNbV4HeY+IClzDvkfxoKOmJZwDztbWXZHeffA=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch212-cu126-aarch64-linux/metadata.json.sigstore b/build/torch212-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..623199fb556c911d35e0d302b00d2b097f555690 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321167006","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414639","inclusionPromise":{"signedEntryTimestamp":"MEUCIBw/xah1btDRkfWP36zIOHwVgzWW7qJdVt7MC7UPhW7TAiEAyOlLSYhEKkpJfL8k9DXmY74r909rukzA07bSECOuk48="},"inclusionProof":{"logIndex":"3199262744","rootHash":"9J2rgf0tu4kZ02YusYUiWtqDeezs+J2FKjDoqtU0Rzc=","treeSize":"3199262771","hashes":["HmiIcJL4mRQ+qhWKKeDJr92yRI/pkZTlL2rjwKYcEJg=","H1i6ZdqLDCeFAUgo8X0WXT/VEG3PKycZGhfeLEgjRuQ=","FHk4c+jwS3uKOz8XuekJw1FQsx6NJec3UuQ7mz/IH7s=","Mra9ooas9e8mholW2hIq1CbL9SZPPG9GjLngSlA6yoQ=","+PN4IilcRGRcSwm0oubjzjlgJckG54/MDFnHIvxV60I=","lssuFTT0oqY11qy63nK2MuOei88+Yng4z6XS19Cby98=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199262771\n9J2rgf0tu4kZ02YusYUiWtqDeezs+J2FKjDoqtU0Rzc=\n\n— rekor.sigstore.dev wNI9ajBFAiAJTnKOO9WhEg7D9gDyO7ukN0YzxZYKR7DwUuBtQmR6lAIhALbZCqRzvDiBuAU76rvQ5NbBTh5dN7vQkUzRQlCAe5Km\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQguDhONePiSX5r7zmtff3ahr8fWo23VOoyL0va7ebKiBgCFQC1PB0X+djb7UfGc7g2Yhe5xQibkBgPMjAyNjEwMTkxMjU3MTZaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTcxNlowLwYJKoZIhvcNAQkEMSIEIEQsfjUD9Gzq9EZnsypdUlRI+/urVYZnVQfSUk1TyVghMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMFNMZgE+bFL6C7dv4Iyyadm0EPzBzNY0Jo92PIndIPleKVYNcRyUT1tST5ap4BLebgIwcjOSS+bZZwaJuB44t4ozgWI9G/HqlnQ+GzL+YF6e5lrY+bXI2kc0Hm4RDyjh/xJX"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"tRq2bmVu88c09MDK2lRWsM28gX7b/r72xw2gigtyd0w="},"signature":"MEUCIQDY4AwbQPclRXNP5LLtlBHn4+YpBPCw9cDfeogiTxfKkgIgTdY/z5P4G4eZ9LYQjQ9coWq5+uVCbg6OV38njq8iyB8="}} \ No newline at end of file diff --git a/build/torch212-cu126-aarch64-linux/symbols.json b/build/torch212-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch212-cu130-aarch64-linux/__init__.py b/build/torch212-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch212-cu130-aarch64-linux/_ops.py b/build/torch212-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch212-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch212-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..016a27889725529980e8153f11bc334ca5888847 --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:81e2746171e37edebd22caddaff86def9b6652d3f790f5f43f66e1f13c00ff75 +size 428456 diff --git a/build/torch212-cu130-aarch64-linux/metadata.json b/build/torch212-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..46dafc209de4a7e836435273fe6d41da9bf17d07 --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "geJ0YXHjft69Isrdr/ht75tmUtP3kPX0P2bh8TwA/3U=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch212-cu130-aarch64-linux/metadata.json.sigstore b/build/torch212-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..fe3425632a19c7230fdc8ac80b52639f4ec9365e --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"MIIHKzCCBrGgAwIBAgIUUQzn0tN//mv6WObIFzrNIuINHxYwCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjYxMDE5MTI1NzE5WhcNMjYxMDE5MTMwNzE5WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEOPIsWC+4Qa3nxDlADoklRoPr1fj9EZ/kLZrcFLP5yb86hMj4v7/S5ggxJchwq7AXpZjwbp/vOM66IBQWDv/zOaOCBdAwggXMMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAfBgNVHSMEGDAWgBTf0+nPViQRlvmo2OkoVaLGLhhkPzBrBgNVHREBAf8EYTBfhl1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50LmNvbTAfBgorBgEEAYO/MAECBBF3b3JrZmxvd19kaXNwYXRjaDA2BgorBgEEAYO/MAEDBChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBMGCisGAQQBg78wAQQEBUJ1aWxkMCsGCisGAQQBg78wAQUEHWh1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5MB0GCisGAQQBg78wAQYED3JlZnMvaGVhZHMvbWFpbjA7BgorBgEEAYO/MAEIBC0MK2h0dHBzOi8vdG9rZW4uYWN0aW9ucy5naXRodWJ1c2VyY29udGVudC5jb20wbQYKKwYBBAGDvzABCQRfDF1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOAYKKwYBBAGDvzABCgQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBsGCisGAQQBg78wAQsEDQwLc2VsZi1ob3N0ZWQwQAYKKwYBBAGDvzABDAQyDDBodHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkwOAYKKwYBBAGDvzABDQQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMB8GCisGAQQBg78wAQ4EEQwPcmVmcy9oZWFkcy9tYWluMBoGCisGAQQBg78wAQ8EDAwKMTA3MTQ3NTUyOTAuBgorBgEEAYO/MAEQBCAMHmh0dHBzOi8vZ2l0aHViLmNvbS9odWdnaW5nZmFjZTAYBgorBgEEAYO/MAERBAoMCDI1NzIwNzQzMG0GCisGAQQBg78wARIEXwxdaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5Ly5naXRodWIvd29ya2Zsb3dzL2J1aWxkLnlhbWxAcmVmcy9oZWFkcy9tYWluMDgGCisGAQQBg78wARMEKgwoZmUyYmI2NmZlZTZjMmE3N2VjY2YwOGEwNTA4ZGM1NzQyOGQ0ODhlZDAhBgorBgEEAYO/MAEUBBMMEXdvcmtmbG93X2Rpc3BhdGNoMGQGCisGAQQBg78wARUEVgxUaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5L2FjdGlvbnMvcnVucy8zOTIzOTY3MjY5MS9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwGcHVibGljMEYGCisGAQQBg78wARgEOAw2cmVwbzpodWdnaW5nZmFjZS9rZXJuZWxzLWNvbW11bml0eTpyZWY6cmVmcy9oZWFkcy9tYWluMIGJBgorBgEEAdZ5AgQCBHsEeQB3AHUA3T0wasbHETJjGR4cmWc3AqJKXrjePK3/h4pygC8p7o4AAAGhVDzmXQAABAMARjBEAiBbV5H1+kvbGKd7rDUn5Cjz1Ovp+jIwKsNiwqgbV7nOGwIgZ6lsSccv8YZPrNnxPmWltoJSvWFNAWobqahuDBgtHO8wCgYIKoZIzj0EAwMDaAAwZQIxAO2XB4HcXi0SJK6eaJ97ACq06x+kzrvF13Hs7nh0MJBitZkIKCOo7S9uJVQRVjqe9AIwQRLo527vO8UOWcM2NZRgaB88QaqmoPWneKKpoYOdP8fvs79vGzpDxyRseNGphFFV"},"tlogEntries":[{"logIndex":"3321167170","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414639","inclusionPromise":{"signedEntryTimestamp":"MEQCIDfH2ahSBp37JmD1F3SQAwu2Mtc3GOuOCUsnP8c4k/mrAiAYZoU3MgehKbS7qsSAbjRLO/YR4dGVok2B1Rv86w3WVg=="},"inclusionProof":{"logIndex":"3199262908","rootHash":"12RtvRPxhTkumePBbamSvuV/ZP350OC0gbxFs/GhRUI=","treeSize":"3199262925","hashes":["xoYqjf/vewEQJaYPxBxRy7qa0AS5ohFWxSl6kozVrGA=","SpvmvuVqA2a/s8FrA54hPJKFae8tOv6+VHSBV8VcC7U=","KRumy9vlv/RY0SB6t7vFyURPF0MfzK3lNpePxaCejHE=","8Uc4jdLf5mjdJEdhWpHrR7qrrFKuqVDzbxWZF3jeKHQ=","tues1FjRWEEVRef0nm0MSXTmG8RCcs4AUjYKd74xhwk=","UfFRl8FmgeTZ2PjF6x0qEvgeXzft/Anah/2OePGaAPE=","Txf7e7O+3N//CFvFUbNQTVqoQoi9SS/bNt8G0McL9To=","ME9/Qb0b2sDeb++eI7zp/b9OXF6Z2A3QtieDi4lZ7DE=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199262925\n12RtvRPxhTkumePBbamSvuV/ZP350OC0gbxFs/GhRUI=\n\n— rekor.sigstore.dev wNI9ajBFAiEAgsNdNPAmEVa0YblXijnX8luIchP5sRo1M9SUrDiQwE4CIC5QyXT2ka9FK9FqtCCv1SGFSIcYitRrip1Tsj59DcYF\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgqUcvy7Sn+neTT3NKzByw4p7vZnHaWK1AuCQxRM696IYCFQCLmEZ0O3WlQidEzXuOKjSZRQ07ABgPMjAyNjEwMTkxMjU3MTlaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTcxOVowLwYJKoZIhvcNAQkEMSIEIGSV41lL8t9ufmhmMjSUolU1nYmI7TdwBBZ6aO60PtUCMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMALMNxcFwkbe5nnanGLbj+zEyzelz0/9BtTgPvAnoMgqgVGX3zTts8u4mrk1cL6y1wIxAPEsjQBOqzCQE2Qw+81ImoH9dxeva+8zXq/Lh0jcUabcE3Ef9fX/495G761Oqx7CWg=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"xOUBCcZRK1n25qL+5WHLCjZZBgBkUxZ1GdVlaNOe6DU="},"signature":"MEYCIQDpCx2skASXFBLupuFU7ORPkb2GD7HopgsZjkw3fxu5PQIhAO8HSRqP0u8JUbtnA49o2Ed3wp078N3q3YgYWuaFDePc"}} \ No newline at end of file diff --git a/build/torch212-cu130-aarch64-linux/symbols.json b/build/torch212-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch212-cu132-aarch64-linux/__init__.py b/build/torch212-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch212-cu132-aarch64-linux/_ops.py b/build/torch212-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch212-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch212-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..371e084985655f3a193a85a455f31720c98b1981 --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:877cefdc05f47a47fa404c05273dfe41f3657f1b9f18f028f8b0dfb9bd370481 +size 496760 diff --git a/build/torch212-cu132-aarch64-linux/metadata.json b/build/torch212-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..70413302fb92ce4bd8d19ab1af8114153ce83403 --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "h3zv3AX0ekf6QEwFJz3+QfNlfxufGPAo+LDfub03BIE=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch212-cu132-aarch64-linux/metadata.json.sigstore b/build/torch212-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..b6d32f161533d7254a8014819203c1448c54e01e --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321167520","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414641","inclusionPromise":{"signedEntryTimestamp":"MEQCIHNyrja6tLbnU8p7OdTZCD9XImy13KPGnFujFMINpmVCAiAD/4f55SpiZrgSbAm2Ei3FjM9fsq2enXJC6GFzTNhWmw=="},"inclusionProof":{"logIndex":"3199263258","rootHash":"6ozo6FmR0+d4NSpKJeTZ++wkM0PKxtvQY3i/SqysiKs=","treeSize":"3199263528","hashes":["pPjX7lZSXy5rjB2x6bRM83zcc6NIOVWanaEhgGOkm44=","poU4+XUwtXRcnin8wqvW/g6lqFz2ZZvHdp1bVfi1FQA=","oEWGoEc9kuLmG6uO1iCnVjMqX5G0UFWyLp6TFL7PuQA=","qkVWgl06mFTZZtaxIIRzKK74tVrsTsPHK9geONgui4Q=","eDQI2n6z8L/pbcmGtHdaUY66epWsbhtlN4mRwOcZL8E=","+BnEUx7T41ZBtUJKtdBYO6noss5ryzxG6oi2uPDsywg=","QDtuIwxslp9otLmxpsHQ6wshCwAKM/zYrQ5SEgKX+Os=","5XpTJ626VYYd1e6FfRCl6tWHjfmlGgN7Yke2YKoQPuo=","J3iX4LtLVXbLnIVb1zfeYxeo9gynm29h/H/fnJINIug=","j4CQkuafCSLgxgAmw/+SfLHjWFyC18S57IeGfjES1Hg=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199263528\n6ozo6FmR0+d4NSpKJeTZ++wkM0PKxtvQY3i/SqysiKs=\n\n— rekor.sigstore.dev wNI9ajBEAiAsFteeMhYhOovfBRhaL9Z/CU574tyEvWSDpl7vK2nQ6AIgQk//38RyUzSjPWTEnNLmIprX/cVq43EfOnWvEBsLTzs=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyzADAgEAMIICwgYJKoZIhvcNAQcCoIICszCCAq8CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgw5BLSY8QLaiD5pNEMKlLm/UxP2adfRK4ebOuaAUHyDoCFQDawXR/zKXaoJpc3opDYUOFKrutpRgPMjAyNjEwMTkxMjU3MjFaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHcMIIB2AIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTcyMVowLwYJKoZIhvcNAQkEMSIEIHiKrjIk4gG2lta/2md7uL4Nj1w0ntmVo7lxa3NyBZUPMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRoMGYCMQDTJ7xYPbrn3BIkZVETYVSkBwxQhIBJ7VkyI7FEXy0InhhcHvN8DzXh++mubnOj2nUCMQC9MXa99/bKjAL4586XDPCZCKUz3DU3bh3Rfweoz+7S9yJF9B0zI8WQhJUicVJDO7o="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"VinmrIwujcCI1o81SxQY4vQWfnsI2iU0Cdz5EMPGoe8="},"signature":"MEUCIGeZwo+cbnUmD/fK/NVpG6ne5wfh02s4a30PEFSKlIkuAiEA7/X+lPnerAznVTe/Ke3oueODeehxjDfAApXyYrQgCFM="}} \ No newline at end of file diff --git a/build/torch212-cu132-aarch64-linux/symbols.json b/build/torch212-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch213-cu126-aarch64-linux/__init__.py b/build/torch213-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch213-cu126-aarch64-linux/_ops.py b/build/torch213-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch213-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch213-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..e14d0e1f8548fe83c5808ad6c56814eb3bd0b149 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:349ea33d5b90c38282fb021c25795fd8984e1c637d69946217c0b7c687ed19b0 +size 295232 diff --git a/build/torch213-cu126-aarch64-linux/metadata.json b/build/torch213-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4ac1ff69c7d23b7f42ac83a71f1ac52207241869 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/metadata.json @@ -0,0 +1,42 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "NJ6jPVuQw4KC+wIcJXlf2JhOHGN9aZRiF8C3xoftGbA=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch213-cu126-aarch64-linux/metadata.json.sigstore b/build/torch213-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..0267b6a9460d5e7dc81df1c6cf035380d3064155 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321169086","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414649","inclusionPromise":{"signedEntryTimestamp":"MEYCIQC/NhjDNBdQuwIzEIAxuxgypNwDwog2OU5bm8WNwzVX7wIhAM24klSIHAKBk2iWdPpz12qiMrUFhXX3lXI1mejuw1B2"},"inclusionProof":{"logIndex":"3199264824","rootHash":"I+KYTWOEsC1gB//Ya+4NeqXDVQRVLQtUD0YhoQXPOsM=","treeSize":"3199265553","hashes":["9XLpd2uVgbLr90lKGbnGQ78UXhZRw5h4xiey8I8XGnM=","WRkVw/mdbR7U9H7tR18YrkNkdb4l8qPFB/Q1MJ3wvlY=","8aVptvazkBueY2PJmdDRwf3st4jzb7hFKoZm95y8QhQ=","CsZGLt3R1U+bdlsJqjnGuJ0qpcES9B1uRkEJs6Jyhz8=","LpEu/ehGp9DphPzBFM+znAD6f48qRjDJoHgbeKbRny4=","RaYLGbLWh9ivdRbN9BVkVaUtissXICYCo0tynFLCMmE=","d6DGKcZCOPgtHeUxYGbu4Pg0RyuutY9hgGr6F2fniG4=","td4XzJkiY3ZlIuxew/0jsmTqg0qh5b+sxN0QyuyRTKU=","3l5n2pGTFA1+0ntw6k04UzPWBU65AbpTfYDoLNDfUNg=","Xra0C+okSTuwUjC6t7MRdPOqV88Zfi3GbZ/eTvichU4=","svWiPCq5pY/4vgsNS6skQAzHbvURW0CHrBM5DdQNF+8=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199265553\nI+KYTWOEsC1gB//Ya+4NeqXDVQRVLQtUD0YhoQXPOsM=\n\n— rekor.sigstore.dev wNI9ajBEAiA2Cy9IfEWOZFgPNiQj9xfr+3EgNYnEPYIqM6ywpeEvEQIga7ylCBmxmgaLUBfMQVpfZbIpILS7renZ8LptRHYgGuw=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgYawK1yITtaLmcTyOFWz8U3t2Q868ZAryW5/ajwUaobICFGOZUtx5i0q0uiq7F0kHzlItus8mGA8yMDI2MTAxOTEyNTcyOVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1NzI5WjAvBgkqhkiG9w0BCQQxIgQgBX7hFDppp3JNy5OF06GiJ4mwiDnoCuK2XNRDFil2pRAwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxAJis/i6+3WTUno770M4gJtTwJc+ZF01+3I71SD/0ZRRSbUNgk36WnCQgyS3fULqUBgIwcScb5rZojWtf8+8/9uBp31rU7AGFRyKaj6cPL8d2ChVBCsetwUxVyMa0es3E7MK8"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"6a9HBTq/UtNkugMikV30/l7T/+tnehplmTLo0e4ynOM="},"signature":"MEYCIQCN2USm3G6EM6ngLmWPdkRPredOSjnHWZwO6NukFv+ihwIhAPP1uNxo25o3ezYCj1pN+IMt7Cj6b3oxxzOkkhhZChye"}} \ No newline at end of file diff --git a/build/torch213-cu126-aarch64-linux/symbols.json b/build/torch213-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch213-cu130-aarch64-linux/__init__.py b/build/torch213-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch213-cu130-aarch64-linux/_ops.py b/build/torch213-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch213-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch213-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..0ef7bfabbeebdcf7c687c684debdfcdc99c5e893 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12e5148bffc5b1d2128036e778fa503ad8c2909f8a40e400ee3a5edcc6e2a491 +size 428824 diff --git a/build/torch213-cu130-aarch64-linux/metadata.json b/build/torch213-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b09ea574d45978719863796c63a0fd002de62e74 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "EuUUi//FsdISgDbnePpQOtjCkJ+KQOQA7jpe3MbipJE=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch213-cu130-aarch64-linux/metadata.json.sigstore b/build/torch213-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..e3f40b97fe6a9dbf8c30719fbf70adc765d20c5e --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321170020","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414654","inclusionPromise":{"signedEntryTimestamp":"MEUCIQCAhCM05l+9SZUiTYx5zGPMBLKHAqgu8Ex6ozkZvV2UMgIgSZB1yKtQhSX2fg3ZDEncKW7ZJsO1ZUldsAUkH1A1A94="},"inclusionProof":{"logIndex":"3199265758","rootHash":"1UcosHFGzumK4TAfhMxW8edMnOQtMW6fstCMkan1wMg=","treeSize":"3199265976","hashes":["vZL+4barwSAvPtZNTl8YjwqjhIHoF3fBPtU8c9lhbIM=","vwxd+cuqwo0gEj66yHQQHq469R0CfiuRurs3hReVDJ8=","KkJTyTZd0O2AT0KaMPqB4ZEs4lcP8TArwu84ZBIYyb8=","9c72y95xC132rw1Bgb/Wt1m+Xb72MUnQLnrNOmruCNw=","/wMYoiSxmVCDqeo69n4O63qLm6hIysaR1YzpZlzXxxY=","CnUMSZHMLaKlROgjWl1+syY6btUvVnSXjd/vc5JdlGY=","CvwPc9JMfTdcaDnDEpSnnZmE6wtxXg0EURX8akeyobQ=","bwPywLsvAECkAzs0oalplw3grR1ZFmJJE46mL4JVsHU=","Fe+OA25z7z5CJeMdwXq+X7CsFzaMoxGNhdv8CkUOADM=","DDsBXng9uyjPO32lP2RSEIlDOkp01wDiQ9onQRYY2Ps=","4sMxXDIFoCjShZkzOVWLfG/D3IHfT9fxpanuk5OZbhQ=","svWiPCq5pY/4vgsNS6skQAzHbvURW0CHrBM5DdQNF+8=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199265976\n1UcosHFGzumK4TAfhMxW8edMnOQtMW6fstCMkan1wMg=\n\n— rekor.sigstore.dev wNI9ajBFAiEA+i1y7WvM0ufApw0jXBrSOG8avAV3cjtBahLtWT6yh3ACIA9+HfJU4CGmNdjhFtnZBK94NgDiODIJInJkMpIdE/zV\n"}},"canonicalizedBody":"eyJhcGlWZXJzaW9uIjoiMC4wLjEiLCJraW5kIjoiaGFzaGVkcmVrb3JkIiwic3BlYyI6eyJkYXRhIjp7Imhhc2giOnsiYWxnb3JpdGhtIjoic2hhMjU2IiwidmFsdWUiOiI1M2I3ZjAyNmNhNmE0ZjM5Mzk2ZTJjZWYyMjY4OTYzOGNiMTBjZDkxNGE4YmZlNzJhM2Q5NjhlM2NhZTA4ZWMyIn19LCJzaWduYXR1cmUiOnsiY29udGVudCI6Ik1FUUNJRm81WXNuUWdQQmpTTEJGbTJNbjhaazBaaG56TFZtTkY3LzEvL1NSVlpaOEFpQWRyT2NkSkZqczVkT2xXdkpLNmozSE54cmowVTJCcUlWSnBNd0tqRXVIWXc9PSIsInB1YmxpY0tleSI6eyJjb250ZW50IjoiTFMwdExTMUNSVWRKVGlCRFJWSlVTVVpKUTBGVVJTMHRMUzB0Q2sxSlNVaE1ha05EUW5KUFowRjNTVUpCWjBsVlpVOXdhakpEZW14Qk1HeEhjV2h1Vmt0eGFqWkdaMDVJYURZMGQwTm5XVWxMYjFwSmVtb3dSVUYzVFhjS1RucEZWazFDVFVkQk1WVkZRMmhOVFdNeWJHNWpNMUoyWTIxVmRWcEhWakpOVWpSM1NFRlpSRlpSVVVSRmVGWjZZVmRrZW1SSE9YbGFVekZ3WW01U2JBcGpiVEZzV2tkc2FHUkhWWGRJYUdOT1RXcFplRTFFUlRWTlZFa3hUbnBOTUZkb1kwNU5hbGw0VFVSRk5VMVVUWGRPZWswd1YycEJRVTFHYTNkRmQxbElDa3R2V2tsNmFqQkRRVkZaU1V0dldrbDZhakJFUVZGalJGRm5RVVZEYkhKQ1UwbDNkalIyZGk5aWJFUnJaRVJ6U0ZsQk5YVXZZVlJvZWxsMmVsaEZRWGdLTXpOME5XVXZhMHd4T1V4cVZURjNMeXMwVkhSQ1lsUlpkblZhU0U5U01XVlhNVFp5V0RaRlkyaG9aM28xTTNWRlJuRlBRMEprU1hkbloxaFBUVUUwUndwQk1WVmtSSGRGUWk5M1VVVkJkMGxJWjBSQlZFSm5UbFpJVTFWRlJFUkJTMEpuWjNKQ1owVkdRbEZqUkVGNlFXWkNaMDVXU0ZOTlJVZEVRVmRuUWxSbUNqQXJibEJXYVZGU2JIWnRiekpQYTI5V1lVeEhUR2hvYTFCNlFuSkNaMDVXU0ZKRlFrRm1PRVZaVkVKbWFHd3hiMlJJVW5kamVtOTJUREprY0dSSGFERUtXV2sxYW1JeU1IWmhTRlp1V2pKc2RWb3lXbWhaTWxWMllUSldlV0p0Vm5OamVURnFZakl4ZEdSWE5YQmtTR3QyVEcxa2NHUkhhREZaYVRrellqTktjZ3BhYlhoMlpETk5kbGx1Vm5CaVIxRjFaVmRHZEdKRlFubGFWMXA2VERKb2JGbFhVbnBNTWpGb1lWYzBkMDlSV1V0TGQxbENRa0ZIUkhaNlFVSkJVVkZ5Q21GSVVqQmpTRTAyVEhrNU1HSXlkR3hpYVRWb1dUTlNjR0l5TlhwTWJXUndaRWRvTVZsdVZucGFXRXBxWWpJMU1GcFhOVEJNYlU1MllsUkJaa0puYjNJS1FtZEZSVUZaVHk5TlFVVkRRa0pHTTJJelNuSmFiWGgyWkRFNWEyRllUbmRaV0ZKcVlVUkJNa0puYjNKQ1owVkZRVmxQTDAxQlJVUkNRMmh0V2xSS2FRcFphbGt5V20xV2JFNXRUWGxaVkdNeldsZE9hbHBxUVRSWlZFRXhUVVJvYTFsNlZUTk9SRWswV2tSUk5FOUhWbXROUWsxSFEybHpSMEZSVVVKbk56aDNDa0ZSVVVWQ1ZVb3hZVmQ0YTAxRGMwZERhWE5IUVZGUlFtYzNPSGRCVVZWRlNGZG9NVm95WkhCaWJXUnRXVmRPYkV3eWRHeGpiVFZzWWtoTmRGa3lPWFFLWWxoV2RXRllValZOUWpCSFEybHpSMEZSVVVKbk56aDNRVkZaUlVRelNteGFiazEyWVVkV2FGcElUWFppVjBad1ltcEJOMEpuYjNKQ1owVkZRVmxQTHdwTlFVVkpRa013VFVzeWFEQmtTRUo2VDJrNGRtUkhPWEphVnpSMVdWZE9NR0ZYT1hWamVUVnVZVmhTYjJSWFNqRmpNbFo1V1RJNWRXUkhWblZrUXpWcUNtSXlNSGRpVVZsTFMzZFpRa0pCUjBSMmVrRkNRMUZTWmtSR01XOWtTRkozWTNwdmRrd3laSEJrUjJneFdXazFhbUl5TUhaaFNGWnVXakpzZFZveVdtZ0tXVEpWZG1FeVZubGliVlp6WTNreGFtSXlNWFJrVnpWd1pFaHJka3h0WkhCa1IyZ3hXV2s1TTJJelNuSmFiWGgyWkROTmRsbHVWbkJpUjFGMVpWZEdkQXBpUlVKNVdsZGFla3d5YUd4WlYxSjZUREl4YUdGWE5IZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1EyZFJjVVJEYUcxYVZFcHBXV3BaTWxwdFZteE9iVTE1Q2xsVVl6TmFWMDVxV21wQk5GbFVRVEZOUkdocldYcFZNMDVFU1RSYVJGRTBUMGRXYTAxQ2MwZERhWE5IUVZGUlFtYzNPSGRCVVhORlJGRjNUR015Vm5NS1dta3hiMkl6VGpCYVYxRjNVVUZaUzB0M1dVSkNRVWRFZG5wQlFrUkJVWGxFUkVKdlpFaFNkMk42YjNaTU1tUndaRWRvTVZscE5XcGlNakIyWVVoV2JncGFNbXgxV2pKYWFGa3lWWFpoTWxaNVltMVdjMk41TVdwaU1qRjBaRmMxY0dSSWEzZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1JGRlJjVVJEYUcxYVZFcHBDbGxxV1RKYWJWWnNUbTFOZVZsVVl6TmFWMDVxV21wQk5GbFVRVEZOUkdocldYcFZNMDVFU1RSYVJGRTBUMGRXYTAxQ09FZERhWE5IUVZGUlFtYzNPSGNLUVZFMFJVVlJkMUJqYlZadFkzazViMXBYUm10amVUbDBXVmRzZFUxQ2IwZERhWE5IUVZGUlFtYzNPSGRCVVRoRlJFRjNTMDFVUVROTlZGRXpUbFJWZVFwUFZFRjFRbWR2Y2tKblJVVkJXVTh2VFVGRlVVSkRRVTFJYldnd1pFaENlazlwT0haYU1td3dZVWhXYVV4dFRuWmlVemx2WkZka2JtRlhOVzVhYlVacUNscFVRVmxDWjI5eVFtZEZSVUZaVHk5TlFVVlNRa0Z2VFVORVNURk9la2wzVG5wUmVrMUhNRWREYVhOSFFWRlJRbWMzT0hkQlVrbEZXSGQ0WkdGSVVqQUtZMGhOTmt4NU9XNWhXRkp2WkZkSmRWa3lPWFJNTW1neFdqSmtjR0p0WkcxWlYwNXNUREowYkdOdE5XeGlTRTEwV1RJNWRHSllWblZoV0ZJMVRIazFiZ3BoV0ZKdlpGZEpkbVF5T1hsaE1scHpZak5rZWt3eVNqRmhWM2hyVEc1c2FHSlhlRUZqYlZadFkzazViMXBYUm10amVUbDBXVmRzZFUxRVowZERhWE5IQ2tGUlVVSm5OemgzUVZKTlJVdG5kMjlhYlZWNVdXMUpNazV0V214YVZGcHFUVzFGTTA0eVZtcFpNbGwzVDBkRmQwNVVRVFJhUjAweFRucFJlVTlIVVRBS1QwUm9iRnBFUVdoQ1oyOXlRbWRGUlVGWlR5OU5RVVZWUWtKTlRVVllaSFpqYlhSdFlrYzVNMWd5VW5Cak0wSm9aRWRPYjAxSFVVZERhWE5IUVZGUlFncG5OemgzUVZKVlJWWm5lRlZoU0ZJd1kwaE5Oa3g1T1c1aFdGSnZaRmRKZFZreU9YUk1NbWd4V2pKa2NHSnRaRzFaVjA1c1RESjBiR050Tld4aVNFMTBDbGt5T1hSaVdGWjFZVmhTTlV3eVJtcGtSMngyWW01TmRtTnVWblZqZVRoNlQxUkplazlVV1ROTmFsazFUVk01YUdSSVVteGlXRUl3WTNrNGVFMUNXVWNLUTJselIwRlJVVUpuTnpoM1FWSlpSVU5CZDBkalNGWnBZa2RzYWsxRldVZERhWE5IUVZGUlFtYzNPSGRCVW1kRlQwRjNNbU50Vm5kaWVuQnZaRmRrYmdwaFZ6VnVXbTFHYWxwVE9YSmFXRXAxV2xkNGVreFhUblppVnpFeFltMXNNR1ZVY0hsYVYxazJZMjFXYldONU9XOWFWMFpyWTNrNWRGbFhiSFZOU1VkTUNrSm5iM0pDWjBWRlFXUmFOVUZuVVVOQ1NEQkZaWGRDTlVGSVkwRXpWREIzWVhOaVNFVlVTbXBIVWpSamJWZGpNMEZ4U2t0WWNtcGxVRXN6TDJnMGNIa0taME00Y0Rkdk5FRkJRVWRvVmtRd1pqSjNRVUZDUVUxQlUwUkNSMEZwUlVGc1YySnVVamMwYUcxVk0wSTFWRzlKTW5KdFNsQk5SSFY0VkZsVWVtZGhPQXBTVm14MU5uSllPRFI0VFVOSlVVTlNjR2xhYVVVM1VFRmpPWGRKVmxWVVFURjBTbUpVVURsamJVcFJXazB2YXpsWlVGVmxVRTh2VXpacVFVdENaMmR4Q21ocmFrOVFVVkZFUVhkT2NFRkVRbTFCYWtWQmNreE5TeThyUjNjdlRVZGxiMVF3UTBsU1VqRkRlbU5WVVhsU1JVdExkVEF6WVVFeVpGZElSRWxtSzJNS2RrOUdOVlZVUTFGaVNHUkpSa0ZvUVRBNU1GVkJha1ZCYmxsSFdGRlNTVEEwVlVwRFpsQmtWRWMxTWs1UldHdGlVa3hHZVVkcFpXZHFNRTE0VDBzeVFncE9RalYwYUhobE5rNUdiemh2VHpod1puVXZNMGh4VFdnS0xTMHRMUzFGVGtRZ1EwVlNWRWxHU1VOQlZFVXRMUzB0TFFvPSJ9fX19"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgYP3PCmRP+NGTkJZduochBsE58tVMHco9aOZ5FXR0f2cCFDQ0eKQqI2z4z+x3NbIvgOJpy4MIGA8yMDI2MTAxOTEyNTczNFowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1NzM0WjAvBgkqhkiG9w0BCQQxIgQgnCJ9R38HNzqvTzkq8diSdcoBBQ2+m2eyu95QjRWDyuswgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxANXBC/heO4yOUoIDsx4iwDtz9Mq9uQ2hOaecffOtgRBIEEaDJKx/JhFM6+3Q6xUTVAIwJhZR/S/+pIChiO5SXQbUjhlX4Nr919rdkiN80ksBbb4zUgupysTlyNQ5BmAPKu8o"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"U7fwJspqTzk5bizvImiWOMsQzZFKi/5yo9lo48rgjsI="},"signature":"MEQCIFo5YsnQgPBjSLBFm2Mn8Zk0ZhnzLVmNF7/1//SRVZZ8AiAdrOcdJFjs5dOlWvJK6j3HNxrj0U2BqIVJpMwKjEuHYw=="}} \ No newline at end of file diff --git a/build/torch213-cu130-aarch64-linux/symbols.json b/build/torch213-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch213-cu132-aarch64-linux/__init__.py b/build/torch213-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch213-cu132-aarch64-linux/_ops.py b/build/torch213-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch213-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch213-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..0a0fce02f0e65e2515b4084a897b0725bcd6f859 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4b07229001e11540cdbc49530a4c73a2d3baf2a3a56ec2861ce84b574ea8c660 +size 497136 diff --git a/build/torch213-cu132-aarch64-linux/metadata.json b/build/torch213-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f71a8be5db47e5ff124a1a78b600b60943da7bdf --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "SwcikAHhFUDNvElTCkxzotO68qOlbsKGHOhLV06oxmA=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch213-cu132-aarch64-linux/metadata.json.sigstore b/build/torch213-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..d3d04929a5fe7efdcde0e3237411c437a72a6ede --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321170354","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414656","inclusionPromise":{"signedEntryTimestamp":"MEUCIBm+2FGPHnUl4UULyBj6VxN3gtNGGkrZGJSgmiZslYZaAiEA1sUWZlEEqZKXrSiccBNgjVaBN1KdJjiUKCxYM2zSeXg="},"inclusionProof":{"logIndex":"3199266092","rootHash":"IVi2DzlD3rWAn+d3tjEDxN4wknzZ9bBMTALVoJ7KqYU=","treeSize":"3199267392","hashes":["zu5CKLudqyVgUHjEJTyCQA1Sv1SdBlC4X2usqiDq5sA=","SeKWN3Cl0BpdeEwCx3U2lOwf0+HtmVUU7Yeknz3aTqU=","xIsHnUJpi/1ZbhtqP9k9qE6QDQJmsapwyG6oMeldBCM=","WEKzxaH9QQBiB03SrVzp+EVao+FEjxKzcU79wJDH7r4=","1y6OLjblfOShwucJTpnEPAjsrJmmTFhkcrUaB/tZV+w=","aX/jF7Zes3SJFsMXfVDz3lQ/qRqy3LWyrolN7gjzwmw=","Hjrod+BdBphNFHlKaW2MAk4HivLzrIiWF9+neMlJH5M=","EUWEUGmOg13QFmNFHpOc/tB/yZ2k0QnYth1+KFGDRck=","HOyO5ZSVYRzU9hdYl9EoydrFaJJEIwYnphBg4oh7+7w=","Lu5HfcDzn9jT4hxFycmK7VBMmIyXc3BHoH735YKIrr4=","+uCJUj53KSeGEOtYNr52bP9ZiEMsW8scYp18AOvwQuU=","svWiPCq5pY/4vgsNS6skQAzHbvURW0CHrBM5DdQNF+8=","8IGZfnlwnhQgxiZX1+wFohIpo+a2SA95KXoMygpDPLk=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199267392\nIVi2DzlD3rWAn+d3tjEDxN4wknzZ9bBMTALVoJ7KqYU=\n\n— rekor.sigstore.dev wNI9ajBGAiEAyK+7L2u2wNZcTj3wLILHUr0pxz+RNUDnN+JofCeLf8oCIQDHg5aV9IZGzdjD5TAPx1i7HJPPX/Cd9FB6xl0DKiHrEQ==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgqeGkmZ+IvEqPoeOmy2q/Twt87dsDEBleV0DOrnpt8c0CFCOB/N6SeKdhWTh3sB++/JdM4bmzGA8yMDI2MTAxOTEyNTczNlowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1NzM2WjAvBgkqhkiG9w0BCQQxIgQghjj4cPPKZm3ZWqE7oO9QtiCWbS8DAYBCrp/oC43spGEwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxAOwMMzmeYxu4lju8P92t7iiY/Hy7AAtkb5Mw+N41oiq5rtgR3KRXhaytjKIbSydAOQIwSms6EIuZTvhVlRv9uGu7oLTRhDc/M5rKQF+GDsoVJpBH6IzpibmU+u2nP/t8MHMO"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"m4kN94Gkz/lXkqI6KMspdNiCChLFysWkWANHdJh21GY="},"signature":"MEYCIQDeilio9D2Ngsro06Yfu7rGQ1ELHb6LE2U2wowiP8ZzBAIhAJQJ/R6T7cZRzH8cTW+R2ERYLlp4/5GkFJHcUyX/WpaV"}} \ No newline at end of file diff --git a/build/torch213-cu132-aarch64-linux/symbols.json b/build/torch213-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch214-cu126-aarch64-linux/__init__.py b/build/torch214-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch214-cu126-aarch64-linux/_ops.py b/build/torch214-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch214-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch214-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..6a054a5ab7b3a16ccabc50cf615e8e713bc7aed1 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:54fb6dfff59c275ea2c612d3a05746ac0f2d2f8cebf3e46c18ece55f53113fa1 +size 296048 diff --git a/build/torch214-cu126-aarch64-linux/metadata.json b/build/torch214-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a245987b87cf2a11ee0924cd2796a99cda4761e6 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/metadata.json @@ -0,0 +1,42 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "VPtt//WcJ16ixhLToFdGrA8tL4zr8+RsGOzlX1MRP6E=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch214-cu126-aarch64-linux/metadata.json.sigstore b/build/torch214-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..d8a372647c14ce378d00829fed831547402ba61b --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321172587","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414668","inclusionPromise":{"signedEntryTimestamp":"MEUCICFNAYu5y2TmkIXAtn1pMCA8Cy0ZLDuuqbB59LElDAq2AiEAmtc/yNGIHEa2rL3B9h0/j4ZOmN3ZTe42B8n0Qxr00nk="},"inclusionProof":{"logIndex":"3199268325","rootHash":"azNNi+hiOtvFVQqoIzSQOioDxvA5wJFvFuShGzbPlfo=","treeSize":"3199269199","hashes":["DxyiWK6/zTWks3gl4dZJ7bQVeYR8cZZ9z7SMbR6S3Os=","xzIp5z0/uLg+MKS7OjNct16nyhWfEBHo64ZwZIAyWf0=","C69MIfUNjGB78BNiLEAY2qUwpboOUtCLpAhkmjnVvx0=","D4QWPSSBFmGFUqAE2yOMhoM11sBAqEi5i2NFTQXfKoY=","qtxcux+j3hiuvz5Y5itJ5+kyKQ3Z18ENC2U8jkfgQqU=","/iHXJ39suKDwRVS6vj6fmwqHgJtQ9SRZ25w47XMwbXI=","7SU+PPrwJedujwArywBQ3RA1p3QUCmDthmdIbgkDj4Y=","ZNK86cirww9BsBnVkNXABSnbwXmLJTviw6rAfbdS9e0=","AgUIQvw/byhKA/vHLUsn9yTsWcex3MWxboyhtBuuWjo=","22oL19L8lIglsJxRkFF0Io9q+VPn5cEG4yDMez2PKjA=","le+K52XePmREKsbsnmSYa5TfPSDWgqSCMz/XUXj8RTc=","GSfSyMyxOpqXOqo2kM1u0kqm/Ep8JETTBq8WLLb2dMA=","QlRtsagqv5vszNQf4di/XUPEkEj2POxoL6ceW9a5qMo=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199269199\nazNNi+hiOtvFVQqoIzSQOioDxvA5wJFvFuShGzbPlfo=\n\n— rekor.sigstore.dev wNI9ajBGAiEA+8f4ecH66nOzYc1OKt7AfwpSHuXnsrZhwAIlmE0yuNYCIQCulhkSXS/FiaSHD0HzfDgXYZM88iAERFYLu8uZ4LWefw==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgnAlDjU2pATrTcwq94ifs+ex+fxyWTVAjZatLEGxAaU4CFC4BVW5bkZL8u7AIYBnjlAZ4gERFGA8yMDI2MTAxOTEyNTc0NVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdwwggHYAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1NzQ1WjAvBgkqhkiG9w0BCQQxIgQgHyiQ4sNxBy1dMNC0RGSbZNdTSiC9V3jFYNbMhKDQGO0wgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGgwZgIxAJzOtNB06GJv/wBDHYJC3hntDJ/S9cXIbx3+REFzPv48wErHG9T/RfmKMGJEBmucYwIxAMUPy2dem8USsnWykxmiWhaZi1ky2juZQcb939TqhNasS49j1s7UJE+yHeTOt6rymw=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"t8DRpld4pNljfmMqKe12t57uHQzxj9Yv6BEvEE60Sgw="},"signature":"MEUCIHUGQg6j53OQUNnZsML6wCBl1qGSykszL6YtV3FHMmUoAiEAyaQOSs7NWR1zQt3liLh1nCHdfdt7hOcCo/dYiv/aRmM="}} \ No newline at end of file diff --git a/build/torch214-cu126-aarch64-linux/symbols.json b/build/torch214-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch214-cu130-aarch64-linux/__init__.py b/build/torch214-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch214-cu130-aarch64-linux/_ops.py b/build/torch214-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch214-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch214-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..0a6d1ccce0ee094e252523da4bf2003d4bdbbbdc --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:554f1152f2769e89f0e5f3c28df8ae528fceeaa91ee4583ba7bdd1f2e8918719 +size 429648 diff --git a/build/torch214-cu130-aarch64-linux/metadata.json b/build/torch214-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..984c0b2bd82a159c0be291627c3c01f4c77fffd2 --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "VU8RUvJ2nonw5fPCjfiuUo/O6qke5Fg7p73R8uiRhxk=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch214-cu130-aarch64-linux/metadata.json.sigstore b/build/torch214-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..6ea91ebf39c24d1e89320f6e3aedb64d346b03f6 --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"MIIHKzCCBrGgAwIBAgIUBFuo3RH+dpwnWrOf6KZh68l7/mwwCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjYxMDE5MTI1NzU2WhcNMjYxMDE5MTMwNzU2WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEwRdY0sbX+UNEjOKtO3xefa8PYCp5+mMHjTzzWo1LUiFh6gJ5RzjQk3ifLIvFAVviZ8qCOWKVd81tcbjeVBq2RKOCBdAwggXMMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAfBgNVHSMEGDAWgBTf0+nPViQRlvmo2OkoVaLGLhhkPzBrBgNVHREBAf8EYTBfhl1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50LmNvbTAfBgorBgEEAYO/MAECBBF3b3JrZmxvd19kaXNwYXRjaDA2BgorBgEEAYO/MAEDBChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBMGCisGAQQBg78wAQQEBUJ1aWxkMCsGCisGAQQBg78wAQUEHWh1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5MB0GCisGAQQBg78wAQYED3JlZnMvaGVhZHMvbWFpbjA7BgorBgEEAYO/MAEIBC0MK2h0dHBzOi8vdG9rZW4uYWN0aW9ucy5naXRodWJ1c2VyY29udGVudC5jb20wbQYKKwYBBAGDvzABCQRfDF1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOAYKKwYBBAGDvzABCgQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBsGCisGAQQBg78wAQsEDQwLc2VsZi1ob3N0ZWQwQAYKKwYBBAGDvzABDAQyDDBodHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkwOAYKKwYBBAGDvzABDQQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMB8GCisGAQQBg78wAQ4EEQwPcmVmcy9oZWFkcy9tYWluMBoGCisGAQQBg78wAQ8EDAwKMTA3MTQ3NTUyOTAuBgorBgEEAYO/MAEQBCAMHmh0dHBzOi8vZ2l0aHViLmNvbS9odWdnaW5nZmFjZTAYBgorBgEEAYO/MAERBAoMCDI1NzIwNzQzMG0GCisGAQQBg78wARIEXwxdaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5Ly5naXRodWIvd29ya2Zsb3dzL2J1aWxkLnlhbWxAcmVmcy9oZWFkcy9tYWluMDgGCisGAQQBg78wARMEKgwoZmUyYmI2NmZlZTZjMmE3N2VjY2YwOGEwNTA4ZGM1NzQyOGQ0ODhlZDAhBgorBgEEAYO/MAEUBBMMEXdvcmtmbG93X2Rpc3BhdGNoMGQGCisGAQQBg78wARUEVgxUaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5L2FjdGlvbnMvcnVucy8zOTIzOTY3MjY5MS9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwGcHVibGljMEYGCisGAQQBg78wARgEOAw2cmVwbzpodWdnaW5nZmFjZS9rZXJuZWxzLWNvbW11bml0eTpyZWY6cmVmcy9oZWFkcy9tYWluMIGJBgorBgEEAdZ5AgQCBHsEeQB3AHUA3T0wasbHETJjGR4cmWc3AqJKXrjePK3/h4pygC8p7o4AAAGhVD14BAAABAMARjBEAiBKFmQxtXdx2XkcayBnuS7Yfdcc0F3Vp4rCpRrVkgDAbAIgNXueMEDU3hrbS/vBPyQnqIuvOtR7O5tWNaRn60WEH3MwCgYIKoZIzj0EAwMDaAAwZQIxAKYCHdKQDmSWFE+rSz2BMoYkHRsIsfb4iNKuwt6iOZ4f3rWl0nqQKd1xyF73oxC+2AIwJANtnKL8chnOYmktsYcJGOILkg8EX0UY9rySFX7dF3QBF0o5dtYfV/O+JKlmf9BM"},"tlogEntries":[{"logIndex":"3321174118","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414677","inclusionPromise":{"signedEntryTimestamp":"MEQCIAyqtW5a7A+vVUNR6zRQtYTAcZMjhu01+/F0x5GdmhTHAiAZTIaCOWlqkCkG6VNC/cwBIkfFhgPPiilENciyUQRC6Q=="},"inclusionProof":{"logIndex":"3199269856","rootHash":"hnun4ivmFXROBF6v5EZxWvksBuI44MUfui7wbuJyyiY=","treeSize":"3199270229","hashes":["lEtoUxQCLvMaWKt840DTZJVfCAfAhw02sHxpogi4aik=","3q9dFePySXA35SixICINqWTjccN5yTmtddiOPjx0uEQ=","ukWYPmTq0+NxOrr4alFiGdyPcxfdr2JnrhAIsZ5pgGY=","h9M+UPgllF4KMHY22tICoiFgxTRmNmGq5IbzNkVkKdc=","ffOV3GgH4QkUHRkwHkgwaDoa//q+bbWKyiXuxxX57zU=","U3vMrnCKuZfmiWrjai9kU99uix58RAqHmC/fv5OCsSU=","sJY8MM+Zq1B2ksuDaJLhxqUxzY47TowYuDxEbo84LMo=","fte3RAW4oeot2tyauYUVjoh6ayM9OrvKrbH6Z8OWiJg=","urEwwSbnHsKpxYBLeDwDZ3ifPjMB5qDmC/ptGEKCNEw=","FmdRqZ7bN5zfayCj2gbmCxcf0nmwowzj3JzOdUGCQXM=","ej12cKUXt6g3wGkiEn08yRzgdwhru0xJGKj9K9SBH24=","65WyfTdfcIyA1bpbzS7TIyb5mOKlYv1be5oGrm+xlkU=","QlRtsagqv5vszNQf4di/XUPEkEj2POxoL6ceW9a5qMo=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199270229\nhnun4ivmFXROBF6v5EZxWvksBuI44MUfui7wbuJyyiY=\n\n— rekor.sigstore.dev wNI9ajBFAiEA08h97WXjbfB37soXzqaiFo4cGW89XPu7sen7W5qywV0CIE9HBJJA6sKBKR3QUiykozuJ9lnjykWYl7PPWSaAQnlE\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgMPCOsWe+47aIwhRcv1veKqYz+o6QGs4lr2oJToxKydECFQCCz3Hu0PPKA32L2FT8RePss0DI8hgPMjAyNjEwMTkxMjU3NTdaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTc1N1owLwYJKoZIhvcNAQkEMSIEIN9fLBSeVkqmdN8f5iyP1Gqmv9xtadEahM476vhGpkFSMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMH2t1ndVeZfkOP/iXpUGJVq4mC6raoWa4XvJkSzY93KuqepXAM7/5D9WPm1zIGx1VgIwDPdXcVSHcWzpSJn0dGmkSbdXl07XdUW6ncP0DKhMXdk/IsvOrdPit5piUm2+fMnN"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"A+uXGjqfaurHG/pXq/O7KtfwUJuyRaU1zBTK9MAdtyU="},"signature":"MEUCIQDuLIyKbAl3rdFAUbsKqZdtade8zs1AOaWGvmpybT0a3QIgcn6+yGfK6zaCgjoI+3BOPhKQlxjkjjnERmbBVxEwdaU="}} \ No newline at end of file diff --git a/build/torch214-cu130-aarch64-linux/symbols.json b/build/torch214-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch214-cu132-aarch64-linux/__init__.py b/build/torch214-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch214-cu132-aarch64-linux/_ops.py b/build/torch214-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch214-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch214-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..2a704638dc33206d903d8e544ff89587613fa80b --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6954e1eb60a52536093ec5d2e7dd5a015d7f5087204dfe0593955c8eabe3bbc3 +size 497960 diff --git a/build/torch214-cu132-aarch64-linux/metadata.json b/build/torch214-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7c23272e8124fc0d1e1d3b1a822e873cd3903f0e --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "aVTh62ClJTYJPsXS591aAV1/UIcgTf4Fk5Vcjqvju8M=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch214-cu132-aarch64-linux/metadata.json.sigstore b/build/torch214-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..cc3af6d0c9251251d5d4f9d1447421eb6c89a99c --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321175088","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414682","inclusionPromise":{"signedEntryTimestamp":"MEQCIBM1RyjDLFXH5QDR3+KA+jVBpPQJM+N/U45qSHkClA6iAiBPl7wTHNTfO3C6wwBsfgfJ4KV0hzj/xLWa0+mIKqF2PQ=="},"inclusionProof":{"logIndex":"3199270826","rootHash":"2kXSCc0Yky3w84i19/rAeiwrnKu6vSf1OiQVeEZqvTk=","treeSize":"3199271403","hashes":["9deK4+IQpiJLRoOZ+8THGG0gCuN7dUhWadvx0tDtywo=","LTURXU3OViGY2kUZo+MFpIUMI8uExRyMiKoiecxlWl8=","jC8O7E8h8s/ElJWHtQuXEJAy3SqQdG5QL6fIYXAHA+E=","icyqzFx4Nl3ZRYnBLDeXPnKXZyuSvF5a7BvT2b24HFI=","d8oO3x3HwyGCm7YgGat7r9Vzf59TfH9sUYldpEfrs3M=","mOThNUDsoJD7E0T2keUtm+A22vYeOcArg7WR5lKMzeY=","lOksn+j2o7TfNKT77J9YdBdhSL/0jRMu1XZFwrlxtmU=","amgQ97IxKlVeGHI5A3fRxGxc2P1Gnv5oOHIZZ18v8c8=","SYmdtHxF6MPxhdFI9V/4qUMo/iEslIjAhSVDwaAnJzc=","8JHHRyvNQgUaoT7V99YChMNOf2c2edoqJKfbgkzfMH0=","ckDHf5eLh3MmuIi9UVWpf6dqAfnWQxUWYMJzn8AVjIc=","65WyfTdfcIyA1bpbzS7TIyb5mOKlYv1be5oGrm+xlkU=","QlRtsagqv5vszNQf4di/XUPEkEj2POxoL6ceW9a5qMo=","IAgb5vmtBUSL/IGhlZ6WvbEoHaJos31Gdm5QJSEapeY=","YOnLVAkDQnILGEJYSR21xy+ZPDFrax8WvEieGVKzimA=","mzY3Hx1VRL0ZX3vYos1Z+Rl/9nBlVqbiGnsL1HfwPRM=","txTtSg+IN55mPuBgUmUMMAExrloUB/gToZgriqPvjMg=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199271403\n2kXSCc0Yky3w84i19/rAeiwrnKu6vSf1OiQVeEZqvTk=\n\n— rekor.sigstore.dev wNI9ajBFAiAqU4StyvGRs//n1osMyaZzdHzGOzt5sPH393k5h333mwIhANX7f/n4uQbfb87zas9pVEI8XtKhYmL9BD1Hg7Dx9DEk\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyDADAgEAMIICvwYJKoZIhvcNAQcCoIICsDCCAqwCAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgBWA97hPuo+I4pO26h/gyZd85zYFtgJjl3c5kpC5D95MCFDMALd0m127dpMDrwYCLQxme7y2SGA8yMDI2MTAxOTEyNTgwMVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdowggHWAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1ODAxWjAvBgkqhkiG9w0BCQQxIgQggHpVT+Q19NKeiJ1MDomOQG04jMP6nQvwgh0x9v6GPIUwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGYwZAIwR2GUsR4SX2NFRk64+CCyuafA+yWP1Z1sDj1ld8BlbrskWZ6ffRUex4S02hywQuVGAjAb7V/x4jMBBvQR3NhlFMJ6+K2wxwMf3vyi81mbj/AXI/zmPCAe6v11rpK0bYkNaEs="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"4dGd2zjgpgEmetfBAj6cvNyqP6adDSPCU2cA7euFOb8="},"signature":"MEUCIBfzQ4/namQ1tdGlu+T3rdRToMPkP3Eo3ENlOQf9HPVIAiEAtyUVcpSd5/QJxQYmHYs1OuU3sFLo3GdJawqOPDi5TVQ="}} \ No newline at end of file diff --git a/build/torch214-cu132-aarch64-linux/symbols.json b/build/torch214-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch215-cu130-aarch64-linux/__init__.py b/build/torch215-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch215-cu130-aarch64-linux/_ops.py b/build/torch215-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch215-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch215-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..697915117a3a6017e128e24ff13fb5cae1d54c27 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:087fbf0172588d57c4598c07963e33a6e0c9088c24057c3a8cf61f772c697fb9 +size 429648 diff --git a/build/torch215-cu130-aarch64-linux/metadata.json b/build/torch215-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..1e900f0ab811e53f244e489646398c77b1ead703 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "CH+/AXJYjVfEWYwHlj4zpuDJCIwkBXw6jPYfdyxpf7k=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch215-cu130-aarch64-linux/metadata.json.sigstore b/build/torch215-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..4bc05214d7af7d4bad8bb492924960d776fc01b4 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321176084","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414687","inclusionPromise":{"signedEntryTimestamp":"MEUCIF+2Gh/pwM3cM+XSm/e3t+fH8OF2O3RbhcTVO7IcWhtSAiEAoYBWKePfvPWrsTPI9ySsejklvT6dftGfi87aFuge58w="},"inclusionProof":{"logIndex":"3199271822","rootHash":"Q/8MVor6RP2/liepx8taiE3EWyClhKZhpew/1mTpGOM=","treeSize":"3199271941","hashes":["BWUPA0rNlaId2GEBAqkdKHGMlMPrc+vuoU5KwhMid/A=","62YCQqjmRYix+84sVPeNKCcDPqwwYIcnthC82igqaXQ=","Laxx10hN8arukiVX2MqyfF+dsrW6Ej78+gqVWVbVsyI=","f73ixjrSjQMWoP0MW5hkbVUIcSgVilb+x9fupcHvWgc=","lBXTdfr7sgPJBhf0l3Qm5KnNNf2dFlke5D9yrVuVdC8=","fgQorxkVHcZZASdvftR02Be0z4YRctulF8JFI7hehbo=","kQcjFbvzS/K2X1dpti4sXImJvSy3fn5E5qfsS1Vj6ac=","TjkBdWZcZFL0zVsraKPlVupPsM5SC6wKA1TjqSWbnno=","Om2S2A6nZLk0fHrKxsMB/655P3i3P6FS9vMcbFz2c9o=","8f4krJV+ZGoMntpUuDepL0K6CbiIa4v7IvPiXWiSpbM=","tQwpXjCqjKrUZrzOte09++psHMjXzt9m2zO0WDxLDlw=","CWpt4Do8O6e8hS/biFYu3BUBfZS+MxwkFhS5P+8giiY=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199271941\nQ/8MVor6RP2/liepx8taiE3EWyClhKZhpew/1mTpGOM=\n\n— rekor.sigstore.dev wNI9ajBFAiAiaOIdwSLYluTi5WO9/5H9CcnBKRNu+pkcGrZsZfKquQIhANNx/t7bCG97TP2nANAuubLVK0PvWEydIV6hTeRrlcqk\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgE5R73oVvsbZ845YeHk2gOCnp1CIEkK77C9oJOyw7UUQCFBCBJRcYtta+seuZXY96qmqM6kG9GA8yMDI2MTAxOTEyNTgwNlowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1ODA2WjAvBgkqhkiG9w0BCQQxIgQg9mSYIyXoZDHfeWISNXlpL9MnbQLUjnsBlNdFxAVJH+IwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxAIm4IxlH3HUwzyYeSIQi9ESNm721PxPy04+HWEb+BKcmuUN6GRQV5Y4b6IMEfhC2QgIwYIjoINf3vwUa+ZK3yFQCNVnet1m7/9rFum6x/U60emEtjJQ0PLbQguxWPdMc5Vpp"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"MOhlMPvF00iSORsQdTnn9Aoj2SMo+Zu1w6S5jlXzjYY="},"signature":"MEUCIBrcKDGpU2MVUT7zJ1mATKIxlX+edi6rDtM6owyybuD4AiEAipo9VSma75mn9oWXMH+wrl1iN7tiAl4NM/81aiDZgjU="}} \ No newline at end of file diff --git a/build/torch215-cu130-aarch64-linux/symbols.json b/build/torch215-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch215-cu132-aarch64-linux/__init__.py b/build/torch215-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch215-cu132-aarch64-linux/_ops.py b/build/torch215-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch215-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch215-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..14cb10cc20055dade9c81d3612736589281a70d2 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:deaaf70b883b7447226515897f4b5216106660cc605fc9ef572e2888c9ba3391 +size 497960 diff --git a/build/torch215-cu132-aarch64-linux/metadata.json b/build/torch215-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4f152b1bc819a80b61cbaf845031851a4b1b5c90 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "3qr3C4g7dEciZRWJf0tSFhBmYMxgX8nvVy4oiMm6M5E=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch215-cu132-aarch64-linux/metadata.json.sigstore b/build/torch215-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..74f68ef9270528371151780d56dfe471e182e803 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321176866","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414691","inclusionPromise":{"signedEntryTimestamp":"MEQCIGLv8ENdKUMz/2MK4meSl4gTmRgF7UfpZQelRJLEBK0TAiANNxwHkUFZ02efaZbZMBKiFzA6ncTP4gQg1pizCXz3AA=="},"inclusionProof":{"logIndex":"3199272604","rootHash":"SmwhPDMn9leDXLYR8AyZH0N3QsrWnyFZV+JlL8pFQbQ=","treeSize":"3199272898","hashes":["d3Zw4294dnPsCHfYzNwjHwjAhS8Nt3rUOcEOL1AmLEE=","R8JwHSNYx1IyP38mBd71KNnNJL3eBIiWz7baogBuN50=","5VVMTbaie6MVGfTWLfI8wf1/XPNABDQHymV6Sv5UBdE=","iIJsGTDegE8+TdY3FbXt2DtVKC7oGwHqpxeLGVMz+I4=","8Rtr3Zj2jbO2Anx052ct9JoTVkufXiHVc0t5fnkNmeI=","INPm7PeHb7zUL2rWTdLETez6nF/VcfDSGuRas5+Ej94=","cvGcu1nVir7cXLGW4hBYfH69MES7xh8KHYilpNnIZws=","+eOFCvtOvcctLH4wqeKRhWaVDwv/tuq9XBwou+qILPU=","JDRuZM5SE4iOIjelks+TdYxqtXJUtwPeOJEx/srF6Vc=","D7bt8RRcv6zZ425Czm/O4U0Wl8mhIBLwFVfUF+DhOco=","DUR134gF8zkcY7saeCTmmr4tS05JPPGHcwqEXgRw0R4=","CWpt4Do8O6e8hS/biFYu3BUBfZS+MxwkFhS5P+8giiY=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199272898\nSmwhPDMn9leDXLYR8AyZH0N3QsrWnyFZV+JlL8pFQbQ=\n\n— rekor.sigstore.dev wNI9ajBFAiEA3i6xwEG4pWq3fvsWqoojHfn8tYRlnmv6o2s3I9Nx+Z8CIC1VO2WZc3n4Ep8wOk/s0+sgxw79Neow3Sh4CvK0JoNM\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgm7pWbFAxb3haSi8SyCraQ1gjJtRmPgsCxLe2S2X18QYCFHSY5ziZ5OH/lEu1HSZ6cy4PumVhGA8yMDI2MTAxOTEyNTgwOVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTI1ODA5WjAvBgkqhkiG9w0BCQQxIgQg7mlJTpy4G77rJmI42fKXZ2RBIkFFmrpnylxEEeWTkFkwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIwSlqXcWg/Bor+i7B0zb/zz0DORtlYeH1GKQdQhvJac5t8z5L2BZ8pO++Kyz6EYyuiAjEA94ZNNMes237V15mj+krnioYr7mnLttrs/nMe8rKNJz3u5RJ/J8FGjY2fF2CXmYr7"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"NqoXLwzny9zqg8jqa0JpZaqvqSwHDa7g3H1hYKj95oE="},"signature":"MEUCIQDnV6P226QeM/ty/DAnHG+YjLpzeOlE6TJKya4xIbbNrAIgPQ8gWzGpjie07oF0+SiZ9GsiEOAFXJ2nqtxdmQb91v0="}} \ No newline at end of file diff --git a/build/torch215-cu132-aarch64-linux/symbols.json b/build/torch215-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +} diff --git a/build/torch215-cu134-aarch64-linux/__init__.py b/build/torch215-cu134-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6350bb09a2d23a877d737f90d8cd4124f7f66ea --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/__init__.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple + +import torch + +from ._ops import ops + + +def tinygrad_rms_norm( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + RMSNorm(x) = x * (1 / sqrt(mean(x^2) + epsilon)) + + This implementation uses a two-kernel approach: + 1. Compute 1/sqrt(mean(x^2) + epsilon) for each row + 2. Multiply input by the computed factor + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Tuple of (output tensor, rms_inv tensor) + """ + if out is None: + out = torch.empty_like(x) + + hidden_size = x.size(-1) + num_rows = x.numel() // hidden_size + rms_inv = torch.empty(num_rows, dtype=x.dtype, device=x.device) + + ops.tinygrad_rms_norm(out, rms_inv, x, epsilon) + return out, rms_inv + + +def tinygrad_rms_norm_simple( + x: torch.Tensor, + epsilon: float = 1e-6, + out: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Compute RMSNorm using tinygrad-style CUDA kernels. + + This is a simpler interface that only returns the normalized output. + + Args: + x: Input tensor of shape (..., hidden_size) + epsilon: Small constant for numerical stability + out: Optional pre-allocated output tensor + + Returns: + Normalized output tensor + """ + if out is None: + out = torch.empty_like(x) + + ops.tinygrad_rms_norm_inplace(out, x, epsilon) + return out diff --git a/build/torch215-cu134-aarch64-linux/_ops.py b/build/torch215-cu134-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..07f0c6ffee75cecc8d52aa10e8a0e8633f28017b --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _tinygrad_rms_cuda_fe2bb66 +ops = torch.ops._tinygrad_rms_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_tinygrad_rms_cuda_fe2bb66::{op_name}" diff --git a/build/torch215-cu134-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so b/build/torch215-cu134-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..57298c84bf874be1f628e397e03f18e8bcedfa12 --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/_tinygrad_rms_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f1944e4ea4c605256d7ef3187fe8bd663ceca737b072cb663d9a1b3a39be11a +size 431352 diff --git a/build/torch215-cu134-aarch64-linux/metadata.json b/build/torch215-cu134-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ee9ad66e811ad23bca3b2e281db7091e7fbc5def --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/metadata.json @@ -0,0 +1,45 @@ +{ + "name": "tinygrad-rms", + "id": "_tinygrad_rms_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "MIT", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "0dfi4qiWxuB1He7Tox2pesdhYAHIYSGt2ftn9Skrj68=", + "_ops.py": "7PcGAY31Ycgaq3RcrxGAAMmBwZvIEM3+JmZZ51RHMEM=", + "_tinygrad_rms_cuda_fe2bb66.abi3.so": "bxlE5OpMYFJW1+8xh/6L1mPOynN7Byy2Y9mhs6Ob4Ro=", + "symbols.json": "EmIHHgdj+G3ZHTOkusfpvm2PMHpPq7txvyOoLaLKjHw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch215-cu134-aarch64-linux/metadata.json.sigstore b/build/torch215-cu134-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..d8ff22201f3313c1ea4bb89f91b47f9f2ddba5ab --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3321177868","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792414696","inclusionPromise":{"signedEntryTimestamp":"MEYCIQCTwZ1ZzJB18P1LsNqNhVnM0AN/+Bv7/1oIh7AiDzhwuwIhANIrPV3LFulgq5ZgKksHzqhFt/T9T55paTd2XJLt2kLr"},"inclusionProof":{"logIndex":"3199273606","rootHash":"GEnWHxVd+Up18RfPpjv9BBDIcfXm5SNoyE4B0aCCDyE=","treeSize":"3199273627","hashes":["vxnnYJvZi41i1/iA4oaFNJk5s5GIFIO1kpkcc3lWPcI=","syByHgevrqgXu3/A0yA/XXFUym1zhNmorDn4w1VqT2w=","rmdAETqBzLKnAHI9TErTdsiEeUrbFEDeSYuBwotng9I=","qWdP4AqEjscrFNQ6e7/SRokhPk7hmY9FIT/o0f7Sfb0=","VABrcb0T5R1uV/MXFNEw970KaSkjWaT+CQySjAltSUI=","de94b1RxKqseQK/gQftCnFbPi/EophStAF6s9zoKUME=","H60r2V7y99AwmeOS81lNsNWm24J6f6MHzgzkd5W1LTc=","IMRJLRZnqy3sG9WBHBcuRwaRBOKH0BWoDVSziILCdYg=","CWpt4Do8O6e8hS/biFYu3BUBfZS+MxwkFhS5P+8giiY=","kHa2Ke03zePMosAfwPNg2y4kk1ZwjdZi4MKNVX7epiE=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3199273627\nGEnWHxVd+Up18RfPpjv9BBDIcfXm5SNoyE4B0aCCDyE=\n\n— rekor.sigstore.dev wNI9ajBFAiEAwrSGe3E+7KPPIDWAGLd7p6tajOn/h+RSpYYFz0IvFZMCIFw+RrspHocltJOdDKqfik3F2Nnqnjb7P/rOlqOASHD/\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyzADAgEAMIICwgYJKoZIhvcNAQcCoIICszCCAq8CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgsvkQKqg1RTJxyELOJtZGOvblKFdL56NWiLUu52Y+lXsCFQCZiI8YwYrBNwr6RT+ymbbcAGPcpxgPMjAyNjEwMTkxMjU4MTRaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHcMIIB2AIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTEyNTgxNFowLwYJKoZIhvcNAQkEMSIEIFB2h7NDTYuRgYVgjs92ldrwV1H9t3zMiUDQTZlL9US0MIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRoMGYCMQDJ0+gna+cS5L/lSxArAsV8d/BJZgi6QSPdtl2uxyhN3zOlfV7SiH+UwRoPs0QHOh0CMQD0uFqgMINwE3T5leHxNr6/l/Oh9p8AeEYK/pJk+F1lF/ZeXkSf6GfnZ0mBNLRpXiA="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"P4NptXA9Czt6t5W2BTYtoO/qYqAjmVB2wRTFYHcrpro="},"signature":"MEQCIDIYP1OpaqWZ84Kdy221TWukUrO9d3P/svV+YcFt5wbnAiBROS0+DvC9TLNIQgg7TP7RqMAMQ+nQufezFNNVz9IkYQ=="}} \ No newline at end of file diff --git a/build/torch215-cu134-aarch64-linux/symbols.json b/build/torch215-cu134-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..7be2a64ca93c5b30d4cbf8c75d1e8255d3119983 --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/symbols.json @@ -0,0 +1,6 @@ +{ + "schema_version": 1, + "module": "_tinygrad_rms_cuda_fe2bb66", + "functions": [], + "layers": [] +}