Share via

Résolution des problèmes hybrides intégrés

  • Article

Notes

Ce contenu s’applique uniquement au QDK classique.

Le développement et l’exécution d’algorithmes hybrides intégrés sur le dernier matériel pris en charge sont un domaine nouveau et en évolution rapide. Cet article décrit les outils et méthodes actuellement disponibles, ainsi que les problèmes connus, et est mis à jour à mesure que de nouvelles fonctionnalités sont prises en charge.

Limitations et restrictions des fonctionnalités

Le tableau suivant répertorie les limitations et restrictions actuellement connues de l’ensemble de fonctionnalités hybrides intégrées. Le fait de connaître ces limitations peut vous aider à éviter les erreurs lorsque vous explorez des programmes hybrides intégrés. Cette table est mise à jour à mesure que la fonctionnalité est développée.

Élément Notes
Bibliothèques prises en charge À compter de cette version, toutes les bibliothèques du QDK ne prennent pas en charge les programmes hybrides intégrés.
Avertissements du compilateur Par défaut, targetles erreurs spécifiques du compilateur sont converties en avertissements. Veillez à valider votre code sur le simulateur, l’émulateur ou le validateur fourni par le targetfournisseur de matériel pour détecter les problèmes avant de s’exécuter sur du matériel quantique.
Types de données composites L’utilisation de types de données composites, tels que les types de structure, les tuples et les types séquentiels, y compris les tableaux, n’est actuellement pas prise en charge avec les programmes hybrides intégrés. Cette limitation exclut également l’utilisation de telles structures de données pour les valeurs pouvant être appelées. En outre, les programmes intégrés ne peuvent pas utiliser de sous-routines comme valeurs de première classe, et l’utilisation de types de fonctions est limitée aux fonctions LLVM déclarées globalement qui peuvent être appelées dans le cadre de l’exécution du programme.
Boucles ou récursions illimitées Les boucles illimitées et les récursivités de fonction directes ou indirectes sont hors de portée pour cette version.
Allocations et accès dynamiques aux qubits Les fonctions runtime pour l’allocation et la mise en production des qubits ne sont pas disponibles, et l’absence de prise en charge des variables locales et des types de données composites empêche tout alias de qubit.
Applications partielles L’utilisation d’une application partielle pour définir un callable visible dans une étendue d’espace de noms n’est pas prise en charge.
Tableaux Utilisez des plages plutôt que des tableaux, lorsque cela est possible. Pour les petites boucles où les performances ne sont pas un problème, l’utilisateur peut préférer utiliser des plages (mémoire contiguë) pour éviter de sortir de la mémoire allouée.
Prise en charge des entiers La prise en charge matérielle actuelle de Quantinuum pour les entiers est limitée aux valeurs non signées 32 bits, même si Q# les entiers sont traités comme 64 bits signés dans le code. Cette limitation peut affecter certaines opérations et comparaisons au niveau du bit. Il est recommandé d’utiliser des valeurs entières positives pour les programmes hybrides intégrés.
Retour de valeurs constantes Les programmes qui retournent des valeurs constantes Result (par exemple, Zero ou One) ne sont pas pris en charge.
Limitations du registre classique Chaque prise en charge target a un nombre de registres classiques spécifiques au matériel, et votre compilation peut échouer si le programme sous-jacent utilise plus de registres classiques que de registres disponibles. Ces défaillances se produisent généralement avec les structures de boucle.

Messages d’erreur et résolution des problèmes

Compilation incomplète

  • Code d’erreur : honeywell - 1000
  • Message d’erreur : 1000 : Erreur de compilation : Erreur interne : Compilation incomplète
  • Type : erreur de travail
  • Source : Compilateur cible

Cette erreur peut se produire lorsqu’un programme qui implémente l’un des scénarios suivants est soumis :

  • Comparaison d’entiers non prise en charge.

    operation IntegerComparisons() : Bool[] { 
    use register = Qubit[2]; 
    mutable i = 0; 
    if (MResetZ(register[0]) == Zero) { 
        set i += 1; 
    } 
    mutable j = 0; 
    if (MResetZ(register[1]) == One) { 
        set j += 1; 
    } 
    let logicalResults = [ 
        // Supported: equality comparisons with non-negative constants. 
        i == 0, 
        // Supported: equality comparisons between integer variables. 
        i == j, 
        // Not supported: equality comparisons with negative constants. 
        i == -1, 
        // Not supported: non-equality integer comparisons. 
        i < 0, 
        i <= i, 
        i > 0, 
        i >= j 
    ]; 
    return logicalResults; 
}

  • Boucles non prises en charge qui dépendent des résultats de mesure des qubits.

    operation UnboundedLoops() : Result { 
    use q = Qubit(); 
    H(q); 
    use t = Qubit(); 
    repeat { 
        X(t); 
        H(q); 
    } 
    until MResetZ(q) == One; 
    return MResetZ(t); 
}

Dépassement du nombre maximal autorisé de registres classiques

  • Code d’erreur : honeywell - 1000
  • Message d’erreur : 1000 : Erreur de compilation : Dépassement du nombre maximal autorisé de registres classiques
  • Type : erreur de travail
  • Source : Compilateur cible

Cette erreur peut se produire lorsqu’un programme qui nécessite un nombre important de registres classiques est envoyé. Certains modèles qui peuvent provoquer ce problème sont pour les boucles qui contiennent un grand nombre d’itérations, des instructions profondément imbriquées si , ou un grand nombre de mesures de qubits.

operation ClassicalRegisterUsage() : Result { 
    use q = Qubit(); 
    use t = Qubit(); 
    mutable count = 0; 
    for _ in 1 .. 100 { 
        H(q); 
        if (MResetZ(q) == One) { 
            X(t); 
        } 
        if (MResetZ(t) == One) { 
            set count += 1; 
        } 
    } 
    return MResetZ(t); 
}

Avertissement QS5023

  • Code d’erreur : Avertissement QS5023
  • Message d’erreur : le ne prend pas en charge la target{0} comparaison des résultats de mesure
  • Type : Avertissement
  • Source : Compilateur cible

Avertissement QS5024

  • Code d’erreur : Avertissement QS5024
  • Message d’erreur : Les résultats de mesure ne peuvent pas être comparés ici. Le target{0} seul prend en charge la comparaison des résultats de mesure dans le cadre de la condition d’une instruction if ou elif dans une opération.
  • Type : Avertissement
  • Source : Compilateur cible

Avertissement QS5025

  • Code d’erreur : Avertissement QS5025
  • Message d’erreur : Une instruction de retour ne peut pas être utilisée ici. ne target{0} prend pas en charge les instructions de retour dans les blocs conditionnels qui dépendent d’un résultat de mesure.
  • Type : Avertissement
  • Source : Compilateur cible

L’avertissement suggère que vous devez avoir votre instruction return dans le dernier bloc.

Avertissement QS5026

  • Code d’erreur : Avertissement QS5026
  • Message d’erreur : La variable «{0} » ne peut pas être réaffectée ici. Dans les blocs conditionnels qui dépendent d’un résultat de mesure, le seul prend en charge la target{1} réaffectation des variables qui ont été déclarées dans le bloc.
  • Type : Avertissement
  • Source : Compilateur cible

Cet avertissement indique que votre programme doit être adapté pour s’exécuter sur le target matériel. Définissez une opération uniquement pour le corps de la boucle qui prépare un état et le mesure, puis exécutez-la en tant que travail.

Avertissement QS5027

  • Code d’erreur : Avertissement QS5027
  • Message d’erreur : l’callable {0} nécessite des fonctionnalités d’exécution qui ne sont pas prises en charge par .target{1}
  • Type : Avertissement
  • Source : Compilateur cible

Cet avertissement indique que votre programme utilise des callables qui tentent d’effectuer des calculs classiques qui ne sont pas pris en charge sur le target matériel. Par exemple, certains fournisseurs de matériel ne prennent pas en charge le calcul classique avec Boolean les types de données ou Int .

Avertissement QS5028

  • Code d’erreur : Avertissement QS5028
  • Message d’erreur : cette construction nécessite une fonctionnalité d’exécution classique qui n’est pas prise en charge par .target
  • Type : Avertissement
  • Source : Compilateur cible

Cet avertissement indique que le Q# programme utilise des fonctionnalités classiques avancées, qui doivent être optimisées pendant le traitement QIR . Si cette optimisation ne peut pas se produire, l’exécution du programme peut échouer à une étape de compilation ultérieure.

Échec de la transformation spécifique de la cible

  • Code d’erreur : QATTransformationFailed
  • Message d’erreur : le message sera spécifique au programme
  • Type : erreur de travail
  • Source : Service Azure Quantum

Cette erreur peut se produire car le service Azure Quantum n’a Quantum Intermediate Representation pas pu transformer suffisamment le programme (QIR) pour pouvoir exécuter le programme sur le spécifié target. Le message d’erreur contient les détails sur QIR qui représentent le programme et ce qui a provoqué l’échec de la validation. Toutefois, il ne fournit pas de détails sur la façon dont l’erreur est liée au code source.

Les scénarios qui peuvent provoquer cette erreur sont très larges. La liste suivante ne les contient pas toutes, mais elle énumère certains des éléments les plus courants :

  • Accès aux éléments de tableau qui se trouvent en dehors de la plage du tableau.

    operation IndexOutOfRange() : Result { 
    use register = Qubit[1]; 
    H(register[1]); 
    return MResetZ(register[1]); 
}

  • Utilisation d’opérations arithmétiques qui ne sont pas prises en charge par .target

    operation UnsupportedArithmetic() : Result { 
    use q = Qubit(); 
    mutable theta = 0.0; 
    for _ in 1 .. 10 { 
        Rx(theta, q); 
        set theta += (0.25 * PI()); 
    } 
    return MResetZ(q); 
}