Première réussite avec le CLI

Évaluez une petite requête XLS sur CPU, puis validez éventuellement une enveloppe de tâche hors ligne et la frontière des sources.

Présentation

Effectuez la vérification et l’installation au préalable. Les commandes ci-dessous utilisent alti du répertoire installé PREFIX/bin. Exécutez-les avec votre utilisateur ordinaire, et non root.

Exécuter une petite évaluation XLS sur CPU

Cette requête additionne deux valeurs sur 8 bits. Elle utilise le moteur XLS natif borné, ne nécessite ni chaîne Google, ni GPU, ni session Cloud, et rend le débordement visible dans le résultat.

Bash
alti capabilities
alti xls eval --request - <<'JSON'
{
  "schema": "altifigence.xls.operation-request.v1",
  "operation": "eval",
  "input_kind": "xls-ir",
  "source": "package demo\ntop fn compute(x: bits[8], y: bits[8]) -> bits[8] { ret sum: bits[8] = add(x, y) }",
  "top": "compute",
  "backend": "cpu",
  "vectors": [["255", "1"], ["0x10", "0b11"]]
}
JSON

Exigez le code de sortie 0 et le résultat moteur pour les deux vecteurs : bits[8]:0x0 et bits[8]:0x13. Cela prouve uniquement l’évaluation de ces entrées. Pour une prise en charge plus large du langage DSLX, utilisez le chemin Google XLS.

Contrôle préalable facultatif de tâche hors ligne

Le workflow suivant lit le manifeste d’actions et valide une enveloppe de tâche ainsi qu’un fichier source local. Il ne lit pas d’identifiants, ne contacte pas de serveur, n’envoie pas de sources, ne soumet pas de travail et n’exécute pas de moteur RTL. Son reçu décrit uniquement la validation locale ; la soumission et l’autorité serveur restent false.

1. Inspecter le manifeste d’actions livré

Bash
alti commands

Une commande réussie écrit un tableau JSON sur stdout et rien sur stderr. Chaque entrée contient name, description, inputSchema, executes, et class. Le CLI public actuel renvoie 25 entrées. La valeur de executes décrit le contrat de répartition ; la commande peut encore exiger un moteur local, une autorisation de compte ou un service hébergé.

2. Préparer une source locale privée

Créez un espace de travail privé dans votre répertoire de travail actuel appartenant à l’utilisateur :

Bash
ALTI_WORKSPACE="$(mktemp -d -p "$PWD" alti-first-success.XXXXXX)"
mkdir -p "$ALTI_WORKSPACE/inputs/rtl"

Enregistrez cette source sans conséquence sous $ALTI_WORKSPACE/inputs/rtl/top.sv:

SystemVerilog
module top(input logic clock, output logic value);
    always_ff @(posedge clock) value <= ~value;
endmodule

Rendez la source lisible et modifiable uniquement par son propriétaire :

Bash
chmod 600 "$ALTI_WORKSPACE/inputs/rtl/top.sv"

Le contrôle préalable rejette une source hors de l’espace de travail, liée plusieurs fois, n’appartenant pas à l’utilisateur actuel ou modifiable par un groupe ou d’autres utilisateurs. N’assouplissez pas le contrôle des autorisations.

Enregistrez ce qui suit sous $ALTI_WORKSPACE/job.json:

JSON
{
  "schema": "altifigence.engine.job.v1",
  "job_id": "offline-job-1",
  "operation": {
    "engine_id": "rtl-engine",
    "operation_id": "analyze",
    "contract_id": "rtl-analysis-request.v1"
  },
  "execution_placement": "cloud",
  "device_preference": {
    "selection": { "mode": "class", "value": "cpu" },
    "fallback": "deny"
  },
  "resources": {
    "cpu_slots": 1,
    "memory_bytes": 536870912,
    "device_slots": 0,
    "device_memory_bytes": 0,
    "max_wall_time_ms": 30000
  },
  "inputs": [
    {
      "artifact_id": "rtl-source-bundle",
      "role": "source_bundle",
      "artifact_schema": "rtl-source-bundle.v1",
      "uri": "workspace://inputs/placeholder",
      "sha256": "0000000000000000000000000000000000000000000000000000000000000000"
    }
  ],
  "cancellation": { "cancellation_id": "cancel-offline-job-1" }
}

Le client remplace l’URI et l’empreinte provisoires dans sa copie de validation en mémoire par la source relative à l’espace de travail sélectionnée et le SHA-256 calculé.

3. Produire le reçu hors ligne

Bash
alti --json job validate \
  --job "$ALTI_WORKSPACE/job.json" \
  --workspace-root "$ALTI_WORKSPACE" \
  --source rtl/top.sv

Un résultat réussi est un objet JSON sur stdout répondant à ce contrat :

Champ

Interprétation requise

receipt_schema

altifigence.cli.engine-job-preflight.v1

status

client_preflight_valid

submitted

Doit valoir false

server_authority_verified

Doit valoir false

job_schema, job_id, operation

L’identité de l’enveloppe validée localement

execution_placement

Le placement demandé dans l’enveloppe, sans preuve de soumission

source.workspace_uri

L’URI normalisée de source relative à l’espace de travail

source.sha256, source.size_bytes

Les preuves de source calculées localement

Le code de sortie 0 signifie uniquement la réussite de ce contrôle préalable client. Il ne signifie pas que la source a compilé, qu’un serveur a accepté la tâche ou qu’un travail a été exécuté.

Sortie d’échec et code de sortie

Avec --json, un échec de validation n’écrit aucun reçu de réussite sur stdout et écrit un objet altifigence.cli.error.v1 sur stderr. Par exemple, un JSON de tâche mal formé produit ENGINE_JOB_JSON_INVALID avec retryable: false et se termine avec le code 1.

Pour l’inspection du manifeste et le contrôle préalable hors ligne :

Code de sortie

Signification

0

Le manifeste a été affiché ou le contrôle préalable client hors ligne a réussi

1

Échec de registre, d’E/S, de frontière des sources ou de validation de tâche

2

Échec de syntaxe de ligne de commande ou d’analyse des arguments

Les autres commandes alti utilisent des codes de sortie absents de ce tableau. 3 est CLASS_NOT_ALLOWED; 4 marque une requête refusée avant répartition, et alti whoami et alti login se terminent tous deux avec le code 4 dans cette version ; une commande adossée à un moteur transmet le code de sortie propre au moteur, avec en plus 126 si le moteur ne peut pas démarrer et 127 s’il est introuvable. Si votre script exécute d’autres commandes que les deux ci-dessus, utilisez le contrat complet de Référence des commandes et traitez par défaut tout code non nul comme un échec.

Gardez stdout et stderr séparés et vérifiez le code de sortie avant d’analyser un reçu. Utilisez les pages de commandes moteur et Cloud pour l’exécution ou la soumission explicites ; aucune ne se produit en effet secondaire du contrôle préalable hors ligne.

Choisir l’étape suivante

Conservez le résultat CPU à deux vecteurs comme contrôle rapide de l’installation. Pour évaluer votre propre conception, modifiez une entrée à la fois et conservez la requête et le résultat complets. Une fonction de langage plus étendue peut nécessiter le chemin Google XLS distinct ; une exécution CUDA exige un choix explicite du backend et un périphérique utilisable.

Pour le travail RTL graphique, poursuivez avec Première exécution RTL DDS. Pour les scripts, utilisez Commandes des moteurs. Pour les fichiers distants enregistrés, connectez-vous via l’authentification Cloud native et sélectionnez la bonne organisation/le bon projet.