Share via

Problemen met geïntegreerde hybride oplossingen oplossen

  • Artikel

Notitie

Deze inhoud is alleen van toepassing op de klassieke QDK.

Het ontwikkelen en uitvoeren van geïntegreerde hybride algoritmen op de nieuwste ondersteunde hardware is een nieuw en snel evoluerend veld. Dit artikel bevat een overzicht van de hulpprogramma's en methoden die momenteel beschikbaar zijn, samen met bekende problemen, en wordt bijgewerkt naarmate nieuwe functies worden ondersteund.

Functiebeperkingen en -beperkingen

De volgende tabel bevat de momenteel bekende beperkingen en beperkingen van de geïntegreerde hybride functieset. Als u zich bewust bent van deze beperkingen, kunt u fouten voorkomen bij het verkennen van geïntegreerde hybride programma's. Deze tabel wordt bijgewerkt wanneer de functionaliteit wordt uitgebreid.

Item Notities
Ondersteunde bibliotheken Vanaf deze release ondersteunen niet alle bibliotheken in de QDK geïntegreerde hybride programma's.
Compilerwaarschuwingen Standaard worden target-specifieke compilerfouten geconverteerd naar waarschuwingen. Zorg ervoor dat u uw code valideert op de simulator, emulator of validator die is geleverd door de targeted hardwareprovider om problemen te detecteren voordat ze worden uitgevoerd op kwantumhardware.
Samengestelde gegevenstypen Het gebruik van samengestelde gegevenstypen, zoals structuurtypen, tuples en opeenvolgende typen, waaronder matrices, wordt momenteel niet ondersteund met geïntegreerde hybride programma's. Deze beperking sluit ook het gebruik van dergelijke gegevensstructuren voor aanroepbare waarden uit. Bovendien kunnen geïntegreerde programma's geen subroutines als eerste klassewaarden gebruiken en is het gebruik van functietypen beperkt tot globaal gedeclareerde LLVM-functies die kunnen worden aangeroepen als onderdeel van de uitvoering van het programma.
Niet-gebonden lussen of recursies Niet-gebonden lussen en directe of indirecte functie-recursies vallen buiten het bereik van deze release.
Dynamische qubittoewijzingen en toegang Runtime-functies voor qubittoewijzing en -release zijn niet beschikbaar en het gebrek aan ondersteuning voor lokale variabelen en samengestelde gegevenstypen voorkomt dat qubitalias worden gebruikt.
Gedeeltelijke toepassingen Het gebruik van een gedeeltelijke toepassing om een aanroepbare zichtbaar te definiëren in een naamruimtebereik wordt niet ondersteund.
Matrices Gebruik indien mogelijk bereiken in plaats van matrices. Voor kleine lussen waarbij de prestaties geen probleem zijn, kan de gebruiker de voorkeur geven aan bereiken (aaneengesloten geheugen) om te voorkomen dat het toegewezen geheugen wordt toegewezen.
Ondersteuning voor gehele getallen De huidige hardwareondersteuning van Quantinuum voor gehele getallen is beperkt tot 32-bits niet-ondertekende waarden, ook al Q# worden gehele getallen behandeld als 64-bits die zijn ondertekend in de code. Deze beperking kan van invloed zijn op sommige bitsgewijze bewerkingen en vergelijkingen. Het wordt aanbevolen om positieve gehele getallen te gebruiken voor geïntegreerde hybride programma's.
Constante waarden retourneren Programma's die constante Result waarden retourneren ( Zero bijvoorbeeld of One) worden niet ondersteund.
Beperkingen van klassiek register Elke ondersteunde target heeft hardwarespecifieke klassieke registeraantallen en uw compilatie kan mislukken als het onderliggende programma meer klassieke registers gebruikt dan beschikbaar is. Deze fouten treden meestal op bij lusstructuren.

Foutberichten en probleemoplossing

Onvolledige compilatie

  • Foutcode: honeywell - 1000
  • Foutbericht: 1000: Compileerfout: Interne fout: Onvolledige compilatie
  • Type: Taakfout
  • Bron: Doelcomppilatie

Deze fout kan optreden wanneer een programma wordt verzonden waarmee een van de volgende scenario's wordt geïmplementeerd:

  • Een niet-ondersteunde vergelijking van gehele getallen.

    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; 
}

  • Niet-ondersteunde lussen die afhankelijk zijn van de resultaten van qubitmetingen.

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

Het maximum aantal klassieke registers is overschreden

  • Foutcode: honeywell - 1000
  • Foutbericht: 1000: Compileerfout: Het maximum aantal klassieke registers is overschreden
  • Type: Taakfout
  • Bron: Doelcomppilatie

Deze fout kan optreden wanneer een programma waarvoor een aanzienlijk aantal klassieke registers is vereist, wordt ingediend. Sommige patronen die dit probleem kunnen veroorzaken, zijn voor lussen die een groot aantal iteraties bevatten, diep genest als-instructies of een groot aantal qubitmetingen.

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); 
}

Waarschuwing QS5023

  • Foutcode: waarschuwing QS5023
  • Foutbericht: de target{0} biedt geen ondersteuning voor het vergelijken van meetresultaten
  • Type: Waarschuwing
  • Bron: Doelcomppilatie

Waarschuwing QS5024

  • Foutcode: waarschuwing QS5024
  • Foutbericht: De meetresultaten kunnen hier niet worden vergeleken. De target{0} enige ondersteunt het vergelijken van meetresultaten als onderdeel van de voorwaarde van een als- of elif-instructie in een bewerking.
  • Type: Waarschuwing
  • Bron: Doelcomppilatie

Waarschuwing QS5025

  • Foutcode: waarschuwing QS5025
  • Foutbericht: een retourinstructie kan hier niet worden gebruikt. De target{0} biedt geen ondersteuning voor retourinstructies in voorwaardelijke blokken die afhankelijk zijn van een meetresultaat.
  • Type: Waarschuwing
  • Bron: Doelcomppilatie

De waarschuwing suggereert dat u uw retourinstructie in het laatste blok moet hebben.

Waarschuwing QS5026

  • Foutcode: waarschuwing QS5026
  • Foutbericht: De variabele kan{0} hier niet opnieuw worden toegewezen. In voorwaardelijke blokken die afhankelijk zijn van een meetresultaat, ondersteunt de alleen het target{1} opnieuw toewijzen van variabelen die binnen het blok zijn gedeclareerd.
  • Type: Waarschuwing
  • Bron: Doelcomppilatie

Deze waarschuwing geeft aan dat uw programma moet worden aangepast voor uitvoering op de target hardware. Definieer een bewerking voor alleen de hoofdtekst van de lus die een status voorbereidt en meet, en voer deze uit als een taak.

Waarschuwing QS5027

  • Foutcode: waarschuwing QS5027
  • Foutbericht: Het aanroepbare {0} vereist runtimemogelijkheden die niet worden ondersteund door de target{1}.
  • Type: Waarschuwing
  • Bron: Doelcomppilatie

Deze waarschuwing geeft aan dat uw programma aanroepbare functies gebruikt om klassieke berekeningen uit te voeren die niet worden ondersteund op de target hardware. Sommige hardwareproviders bieden bijvoorbeeld geen ondersteuning voor klassieke berekeningen met Boolean of Int gegevenstypen.

Waarschuwing QS5028

  • Foutcode: waarschuwing QS5028
  • Foutbericht: Voor deze constructie is een klassieke runtime-mogelijkheid vereist die niet wordt ondersteund door de target.
  • Type: Waarschuwing
  • Bron: Doelcomppilatie

Deze waarschuwing geeft aan dat het Q# programma gebruikmaakt van geavanceerde klassieke functies, die moeten worden geoptimaliseerd tijdens de QIR-verwerking . Als deze optimalisatie niet kan worden uitgevoerd, kan de uitvoering van het programma mislukken in een latere compilatiestap.

Doelspecifieke transformatie is mislukt

  • Foutcode: QATTransformationFailed
  • Foutbericht: Het bericht is specifiek voor het programma
  • Type: Taakfout
  • Bron: Azure Quantum-service

Deze fout kan optreden omdat de Azure Quantum-service het programma ( Quantum Intermediate Representation QIR) niet kan transformeren om het programma te kunnen uitvoeren op de opgegeven target. Het foutbericht bevat de details over QIR die het programma vertegenwoordigen en waardoor de validatie is mislukt. Het bevat echter geen details over hoe de fout is gerelateerd aan de broncode.

De scenario's die deze fout kunnen veroorzaken, zijn zeer breed. De volgende lijst bevat niet alle, maar een aantal van de meest voorkomende items:

  • Toegang tot matrixelementen die zich buiten het bereik van de matrix bevinden.

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

  • Rekenkundige bewerkingen gebruiken die niet worden ondersteund door de 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); 
}