Breng programma's over van 32 bit naar 64 bit. 7 stappen

Laatste update: 04/10/2024
Zet 32-bits programma's over naar 64-bits

Dit artikel beschrijft de belangrijkste stappen bij het overzetten van programma's van 32-bits naar 64-bits systemen . Het beschrijft de voornaamste uitdagingen waarmee ontwikkelaars te maken krijgen bij de migratie van programma's van 32-bits naar 64-bits systemen. Hoewel de lijst met besproken problemen niet volledig is, hopen we in de toekomst een meer gedetailleerde versie van dit artikel te publiceren.

Zet 32-bits programma's over naar 64-bits

Dit zijn de stappen om 32-bits Windows- applicaties succesvol te migreren naar 64-bits Windows-systemen:

Stap 1: De 64-bits modus kan afwijken. Laten we het oplossen

In de context van een computerarchitectuur verwijst de term “64-bit” naar 64-bit gehele getallen en andere gegevenstypen van deze omvang. Met “64-bit”-systemen kunnen 64-bit microprocessorarchitecturen (bijv. EM64T, IA-64) of 64-bit besturingssysteemarchitecturen (bijv. Windows XP Professional x64 Edition) worden bedoeld.

AMD64 (of x86-64, Intel 64, EM64T, x64) is een 64-bits microprocessorarchitectuur en bijbehorende instructieset, ontwikkeld door AMD. Deze instructieset werd door Intel in licentie gegeven onder de naam EM64T (Intel64). De AMD64-architectuur is een uitbreiding van de x86-architectuur met volledige achterwaartse compatibiliteit.

De architectuur werd wijdverspreid als basis voor personal computers en werkstations. IA-64 is een 64-bits microprocessorarchitectuur die gezamenlijk is ontwikkeld door Intel en Hewlett Packard-bedrijven. Het is geïmplementeerd op de Itanium- en Itanium 2-microprocessors. De architectuur wordt voornamelijk gebruikt in multiprocessorservers en clustersystemen.

Wellicht bent u ook geïnteresseerd in: Hoe download ik een PCI-apparaat voor Windows 7 64-bit?

AMD64 en IA-64 zijn twee verschillende 64-bits architecturen die niet compatibel met elkaar zijn. Daarom moeten ontwikkelaars beslissen of ze beide architecturen of slechts één ervan moeten ondersteunen. In de meeste gevallen, tenzij u sterk aangepaste software ontwikkelt voor clustersystemen of uw eigen krachtige DBMS implementeert, zult u waarschijnlijk alleen ondersteuning voor de AMD64-architectuur hoeven te implementeren, die veel populairder is dan IA -64.

Dit is vooral software voor de pc-markt, die bijna 100% bezet is door de AMD64-architectuur. Verderop in het artikel zullen we het alleen hebben over de AMD64 (EM64T, x64) architectuur, omdat deze tegenwoordig de meest actuele is voor applicatiesoftwareontwikkelaars. Als we het over verschillende architecturen hebben, moeten we het begrip “Datamodel” noemen.

Met datamodel bedoelen we de correlaties tussen de geaccepteerde lettergroottes binnen de ontwikkelomgeving. Verschillende ontwikkeltools kunnen verschillende gegevenstypen voor een besturingssysteem hanteren. Meestal is er echter slechts één model dominant, namelijk het model dat het beste aansluit bij de hardware- en softwareomgeving.

Een voorbeeld hiervan is 64-bit Windows, waarvan het oorspronkelijke datamodel LLP64 is. Maar om compatibiliteitsredenen ondersteunt 64-bits Windows het uitvoeren van 32-bits programma's die werken in de ILP32LL-gegevensmodelmodus. Tabel 1 geeft informatie over de basisdatamodellen.

Zet 32-bits programma's over naar 64-bits

Het gebruikte datamodel heeft grote invloed op het ontwikkelingsproces van 64-bits applicaties, omdat er rekening moet worden gehouden met de omvang van de data die in de programmacode worden gebruikt.

Stap 2: Ontdek of u de 64-bits versie van uw product nodig heeft

Je zou je reis naar 64-bits systemen moeten beginnen met jezelf af te vragen: "Moet ik mijn project echt opnieuw ontwikkelen voor een 64-bits systeem?" Beantwoord deze vraag pas na zorgvuldige overweging. Enerzijds loop je het risico achter te blijven op je concurrenten als je geen 64-bits oplossingen aanbiedt. Anderzijds loop je het risico tijd te verspillen aan het ontwikkelen van een 64-bits applicatie die geen concurrentievoordeel oplevert. Laten we de belangrijkste factoren op een rijtje zetten die je kunnen helpen bij het nemen van deze beslissing.

2.1. Duur van de levenscyclus van applicaties

U mag geen 64-bits versie van een applicatie met een korte levenscyclus maken. Dankzij het WOW64-subsysteem werken oude 32-bits applicaties redelijk goed op 64-bits Windows-systemen, en daarom heeft het geen zin om een ​​64-bits programma te maken, aangezien het over 2 jaar niet meer ondersteund zal worden.

Bovendien leert de praktijk dat de migratie naar 64-bits versies van Windows is uitgesteld, en misschien zullen de meeste gebruikers op korte termijn alleen de 32-bits versie van de programmaoplossing gebruiken.

Als u de ontwikkeling en ondersteuning van een programmaproduct op de lange termijn plant, moet u beginnen te werken met de 64-bits versie van uw oplossing. U kunt dit doen zonder overhaast te zijn, maar houd er rekening mee dat hoe langer u niet over een volledige 64-bits versie beschikt, hoe meer problemen u zult ondervinden bij het ondersteunen van deze applicatie die is geïnstalleerd op 64-bits versies van Windows.

2.2. Intensief resourcegebruik van een applicatie

Door een programma opnieuw te compileren voor een 64-bits systeem, kunt u grote hoeveelheden hoofdgeheugen gebruiken en wordt de werking ervan ook met 5-15% versneld. Een toename van 5-10% zal worden verkregen door het gebruik van de architecturale mogelijkheden van de 64-bits processor, bijvoorbeeld een groter aantal registers. De rest van de snelheidsverhoging van 1-5% wordt verklaard door de afwezigheid van de WOW64-laag, die API-aanroepen vertaalt tussen 32-bits applicaties en een 64-bits besturingssysteem.

Als uw programma geen grote hoeveelheden data (meer dan 2 GB) verwerkt en de snelheid niet cruciaal is, is overstappen naar een 64-bits systeem op korte termijn niet noodzakelijk. Overigens kunnen zelfs eenvoudige 32-bits applicaties baat hebben bij een 64-bits omgeving.

U weet wellicht dat een programma dat is gemaakt met de sleutel / LARGEADDRESSAWARE: YES tot 3 GB geheugen kan toewijzen als het wordt gestart op een 32-bits Windows-systeem. Ditzelfde 32-bits programma kan op een 64-bits systeem bijna 4 GB geheugen toewijzen (in de praktijk ongeveer 3,5 GB).

2.3. Ontwikkeling van de bibliotheek

Als u bibliotheken, componenten of andere elementen ontwikkelt met de hulp van externe ontwikkelaars die hun eigen software maken, moet u snel handelen terwijl u de 64-bits versie van uw product maakt. Anders zullen klanten die geïnteresseerd zijn in het lanceren van 64-bits versies op zoek moeten gaan naar alternatieve oplossingen.

Sommige ontwikkelaars van software- en hardwarebeveiliging reageerden bijvoorbeeld traag door 64-bit-programma's uit te brengen, en dat zorgde ervoor dat sommige klanten op zoek gingen naar andere tools om hun programma's te beschermen.

Een bijkomend voordeel van het uitbrengen van een 64-bits versie van een bibliotheek is dat je deze als een apart product kunt verkopen . Klanten die zowel 32-bits als 64-bits applicaties willen ontwikkelen, hoeven dan slechts twee verschillende licenties aan te schaffen.

2.4. Afhankelijkheid van uw product van bibliotheken van derden

Voordat u gaat werken aan het maken van de 64-bits versie van uw product, moet u nagaan of er 64-bits versies van bibliotheken en componenten worden gebruikt. Ken daarnaast het prijsbeleid van de 64-bits versie van een bibliotheek. Als er geen ondersteuning wordt geboden, zoek dan vooraf naar alternatieve oplossingen die 64-bits systemen ondersteunen.

2.5. 16-bits toepassingen gebruiken

Als uw oplossingen nog steeds 16-bits schijven gebruiken, is het tijd om er vanaf te komen. 16-bits toepassingen op 64-bits versies van Windows worden niet ondersteund. We moeten hier één ding uitleggen over het gebruik van 16-bits installatieprogramma's. Ze worden nog steeds gebruikt om sommige 32-bits applicaties te installeren.

Er is een speciaal mechanisme dat een aantal van de populairste 16-bits installatieprogramma's vervangt door hun nieuwste versies. Dit kan leiden tot de misvatting dat 16-bits programma's nog steeds werken in een 64-bits omgeving . Onthoud: dat is niet het geval.

2.6. Code-montage

Vergeet niet dat het gebruik van grote assemblagecode de kosten voor het maken van de 64-bits versie van een applicatie aanzienlijk kan verhogen. Nadat u over alle genoemde factoren heeft nagedacht en alle voor- en nadelen heeft afgewogen, kunt u beslissen of u uw project naar 64-bits systemen moet overbrengen. Als het antwoord ja is, kunnen we verder gaan.

Stap 3: Gereedschapsset

Als u heeft besloten de 64-bits versie van uw product te ontwikkelen en bereid bent er tijd in te steken, is dit nog steeds niet voldoende om succes te garanderen. Het punt is dat je over de volledige noodzakelijke set gereedschappen moet beschikken, en hier kun je met enkele problemen te maken krijgen. De afwezigheid van een 64-bits compiler is misschien wel het eenvoudigste maar meest onoverkomelijke probleem.

  De 7 beste programma's voor webcam. webcams

Als alles duidelijk is over de afwezigheid van een 64-bits compiler, kunnen andere soortgelijke problemen minder transparant lijken en zich pas voordoen in de fase van het overzetten van het project naar een nieuwe architectuur. Daarom adviseren wij u om vooraf na te gaan of alle benodigde componenten aanwezig zijn die u nodig heeft om de 64-bit versie van uw product te implementeren. Het kan zijn dat u voor onaangename verrassingen komt te staan.

Het is natuurlijk onmogelijk om hier alles op te sommen wat je voor een project nodig hebt, maar we gaan verder met een lijst die je op weg kan helpen en je wellicht herinnert aan andere zaken die nodig zijn om je 64-bits project te realiseren :

3.1. Een 64-bits compiler

Er valt nauwelijks meer te zeggen over het belang van een 64-bits compiler. Het moet gewoon zo zijn. Als u van plan bent 64-bits toepassingen te ontwikkelen met de nieuwste versie van Visual Studio, helpt de volgende Tabel 2 u te begrijpen welke editie van Visual Studio u nodig heeft.

64-bits compiler

3.2. 64-bits computers onder controle van een 64-bits besturingssysteem

Je kunt natuurlijk virtuele machines gebruiken om 64-bits applicaties op 32-bits computers uit te voeren, maar dat is te omslachtig en biedt niet het vereiste testniveau. Idealiter zouden de machines minimaal 4-8 GB RAM moeten hebben.

3.3. 64-bits versies van alle gebruikte bibliotheken

Als bibliotheken in broncodes worden gepresenteerd, moet er een 64-bits configuratie van het project zijn. Het kan een moeilijke en ondankbare taak zijn om de bibliotheek zelf bij te werken voor een 64-bits systeem, en het resultaat kan onbetrouwbaar zijn en fouten bevatten. Bovendien kunt u met deze acties licentieovereenkomsten schenden. Als u bibliotheken in de vorm van binaire schijven gebruikt, moet u ook nagaan of er 64-bits schijven zijn.

Je kunt geen 32-bits DLL gebruiken binnen een 64-bits applicatie . Je kunt wel een speciale link maken via COM, maar dat is een aparte, omvangrijke en lastige taak. Houd er ook rekening mee dat je mogelijk extra geld moet uitgeven om de 64-bits versie van de bibliotheek aan te schaffen.

3.4. Gebrek aan geïntegreerde assemblagecode

Visual C++ ondersteunt geen 64-bits inline-assembler. U moet een externe 64-bits assembler gebruiken (bijvoorbeeld MASM) of een implementatie hebben met dezelfde functionaliteit in C/C++.

3.5. Update van de testmethodologie

Het betekent een aanzienlijke herziening van de testmethodologie, het bijwerken van unit-tests en het gebruik van nieuwe tools. We zullen hier later meer in detail over praten, maar vergeet niet om er rekening mee te houden in de fase van het evalueren van de tijdskosten van het migreren van een applicatie naar een nieuw systeem.

3.6. Nieuwe gegevens om te testen

Als u resource-intensieve applicaties ontwikkelt die een grote hoeveelheid hoofdgeheugen gebruiken, moet u ervoor zorgen dat de database met testinvoer wordt aangevuld. Bij het testen van 64-bits applicaties is het een goed idee om de limiet van 4 GB gebruikt geheugen te overschrijden. Veel fouten kunnen alleen onder deze omstandigheden optreden.

3.7. 64-bits beveiligingssystemen

Het gebruikte beveiligingssysteem moet volledige compatibiliteit bieden met 64-bits systemen. Er bestaat al lange tijd geen automatisch beveiligingssysteem voor 64-bits binaire bestanden (Hasp Envelop-programma).

Daarom moest het beveiligingsmechanisme handmatig binnen de programmacode worden geïmplementeerd, en dat was een moeilijkere taak die professionaliteit en tijd vergde. Vergeet problemen met betrekking tot onder meer beveiliging en systeemupdates niet.

3.8. Installateur

U hebt een nieuw installatieprogramma nodig dat 64-bits toepassingen volledig kan installeren. Wij willen u waarschuwen voor een zeer typische fout. Het is het maken van 64-bits installatieprogramma's om 32/64-bits programmaproducten te installeren. Bij het voorbereiden van de 64-bits versie van een applicatie willen ontwikkelaars vaak de "64-bits modus" absoluut maken en een 64-bits installatieprogramma maken, waarbij ze vergeten dat degenen die een 32-bits besturingssysteem gebruiken, zo'n installatiepakket eenvoudigweg niet kunnen starten.

Houd er rekening mee dat het niet de 32-bits applicatie is die samen met de 64-bits versie in de distributiekit zit, maar het installatieprogramma zelf. Want als de distributiekit een 64-bits applicatie is, werkt deze uiteraard niet op een 32-bits besturingssysteem. Het meest onaangename is dat een gebruiker niet kan raden waarom dit gebeurt.

Stap 4: Een project opzetten in Visual Studio 2005/2008

Het maken van de 64-bits configuratie van een project in Visual Studio lijkt eenvoudig genoeg. Moeilijkheden zullen beginnen in de fase van het bouwen van een nieuwe configuratie en het vinden van fouten daarin. Om de 64-bit setup zelf te maken, moet je de volgende 4 stappen uitvoeren:

Stap 1: Start de configuratiemanager, zoals weergegeven in afbeelding 1:

Zet 32-bits programma's over naar 64-bits

Stap 2: Selecteer in de configuratiemanager de ondersteuning voor het nieuwe platform:

Zet 32-bits programma's over naar 64-bits

Stap 3: Kies het 64-bits (x64) platform en, als basis, de instellingen voor de 32-bits versie. Visual Studio corrigeert automatisch alle instellingen die van invloed zijn op de buildmodus.

Zet 32-bits programma's over naar 64-bits

Stap 4: Het toevoegen van een nieuwe configuratie is voltooid en u kunt nu de 64-bits configuratieversie kiezen en beginnen met het compileren van een 64-bits applicatie. De selectie van de 64-bits configuratie voor het bouwen wordt weergegeven in Figuur 4.

Zet 32-bits programma's over naar 64-bits

Als je geluk hebt, hoef je een 64-bits project niet verder te configureren. Maar dit hangt grotendeels af van het project, de complexiteit ervan en het aantal gebruikte bibliotheken. Het enige dat je direct moet aanpassen, is de stackgrootte. Als de stackgrootte in je project is ingesteld op de standaardwaarde van 1 MB, moet je deze voor de 64-bits versie instellen op 2 MB.

Het is niet verplicht, maar het is beter om dit van tevoren te controleren. Als u een andere grootte gebruikt dan de standaardwaarde, is het verstandig om deze voor de 64-bits versie met twee te verhogen. U kunt dit doen door de parameters 'Stack Reserve Size' en 'Stack Commit Size' in uw projectinstellingen te zoeken en aan te passen.

Stap 5: Bouw een applicatie

Hier moeten we u vertellen over de typische problemen die optreden in de compilatiefase van een 64-bits configuratie, bespreken welke problemen optreden in bibliotheken van derden, u vertellen dat de compiler in de code met betrekking tot WinAPI-functies het plaatsen van een pointer niet toestaat in type LONG, en u zult uw code moeten bijwerken en het type LONG_PTG moeten gebruiken. En er is nog veel meer te zeggen.

Helaas zijn er zoveel problemen en zijn de fouten zo verschillend dat we ze niet allemaal in één artikel of zelfs maar in één boek kunnen beschrijven. U zult alle fouten moeten bekijken die de compiler u laat zien en alle nieuwe waarschuwingen die er voorheen niet waren, en in elk specifiek geval moeten uitzoeken hoe u de code kunt bijwerken.

Laten we hier alleen de typen beschrijven die van belang kunnen zijn voor ontwikkelaars bij het porten van applicaties. De meeste hercompilatiefouten hebben betrekking op het gebruik van dezelfde typen:

  • Op t 32 / 32: basistype. Op 64-bits systemen is het nog steeds 32-bits.
  • Lang 32 / 32: basistype. Op 64-bits Windows-systemen is dit nog steeds 32-bits. Houd er rekening mee dat in systemen Linux 64-bit, dit type werd uitgebreid naar 64-bit. Vergeet dit niet als u code ontwikkelt die moet worden gecompileerd voor Windows- en Linux-systemen.
  • maat_t 32 / 64: niet-ondertekend basistype. De grootte van het type is zo gekozen dat je er de maximale grootte van een array naar kunt schrijven die theoretisch mogelijk is. Je kunt veilig een pointer plaatsen om size_t te typen (behalve pointers naar klassefuncties, maar dit is een speciaal geval).
  • ptrdiff_t 32 / 64: vergelijkbaar met het size_t type, maar dit is een ondertekend type. Het resultaat van de expressie waarbij de ene pointer wordt afgetrokken van de andere (ptr1-ptr2) zal het type ptrdiff_t hebben.
  • Wijzer 32/64: De grootte van de aanwijzer hangt rechtstreeks af van de grootte van het platform. Wees voorzichtig bij het converteren van verwijzingen naar andere typen.
  • __int64 64 / 64: 64-bit ondertekend type.
  • DWORD-32/32: 32-bits niet-ondertekend type. In WinDef.h wordt het gedefinieerd als: typedef unsigned long DWORD;
  • DWORDLONG 64/64: 64-bits niet-ondertekend type. In WinNT.h wordt het gedefinieerd als: typedef ULONLONG DWORDLONG.
  • DWORD_PTR 32/64: niet-ondertekend type waarin een aanwijzer kan worden geplaatst. In BaseTsd.h is het gedefinieerd als: typedef ULONG_PTR DWORD_PTR.
  • DWORD32 32 / 32: 32-bits niet-ondertekend type. In BaseTsd.h wordt het gedefinieerd als: typedef unsigned int DWORD32.
  • DWORD64 64 / 64: 64-bits niet-ondertekend type. In BaseTsd.h wordt het gedefinieerd als: typedef unsigned __int64 DWORD64.
  • HALF_PTR 16 / 32: een halve wijzer. In Basetsd.h is het gedefinieerd als: #ifdef _WIN64. typedef int HALF_PTR; #else typedef kort HALF_PTR; #endif
  • INT_PTR 32 / 64: ondertekend type waarnaar een aanwijzer kan worden geplaatst. In BaseTsd.h wordt het gedefinieerd als: #if gedefinieerd (_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR; #endif
  • Lang 32 / 32: ondertekend type dat 32-bit bleef. Daarom moet nu in veel gevallen LONG_PTR worden gebruikt. In WinNT.h wordt het gedefinieerd als: typedef long LONG;
  • LONG_PTR 32 / 64: ondertekend type waarnaar een aanwijzer kan worden geplaatst. In BaseTsd.h wordt het gedefinieerd als: #if gedefinieerd (_WIN64) typedef __int64 LONG_PTR; #else typedef lang LONG_PTR; #endif.
  • LPARAM 32 / 64: parameter om berichten te verzenden. In WinNT.h is het gedefinieerd als: typedef LONG_PTR LPARAM.
  • MAAT_T 32 / 64: analoog van type size_t. In BaseTsd.h is het gedefinieerd als: typedef ULONG_PTR SIZE_T.
  • SSIZE_T 32/64: Analoog van het type ptrdiff_t. In BaseTsd.h is het gedefinieerd als: typedef LONG_PTR SSIZE_T.
  • ULONG_PTR 32 / 64: niet-ondertekend type waarin een aanwijzer kan worden geplaatst. In BaseTsd.h wordt het gedefinieerd als: #if gedefinieerd (_WIN64) typedef unsigned __int64 ULONG_PTR; #else typedef niet-ondertekend lang ULONG_PTR; #endif.
  • WOORD 16/16: Niet-ondertekend 16-bits type. In WinDef.h wordt het gedefinieerd als: typedef unsigned short WORD.
  • WPARAM 32 / 64: parameter om berichten te verzenden. In WinDef.h wordt het gedefinieerd als: typedef UINT_PTR WPARAM.
  smss.exe | Wat is het? Is het gevaarlijk? Oplossingen voor problemen

Dit zijn de typen waarmee u rekening moet houden bij het migreren van 32-bits programma's naar 64-bits Windows-systemen.

Misschien vind je dit ook interessant: Hoe gebruik je al het RAM-geheugen in Windows 10?

6. Diagnose van verborgen fouten

Als u denkt dat u na het herstellen van alle compilatiefouten een langverwachte 64-bits applicatie krijgt, moeten we u teleurstellen. Het moeilijkste deel moet nog komen. In de compilatiefase corrigeert het de meest expliciete fouten die de compiler heeft kunnen detecteren en die meestal verband houden met de onmogelijkheid van impliciete typeconversie.

Maar dit is slechts een klein deel van het probleem. De meeste fouten zijn verborgen. Vanuit het perspectief van de abstracte taal C++ lijken deze fouten veilig en worden ze vermomd door expliciete typeconversies. Het aantal van dergelijke fouten is veel hoger dan het aantal fouten dat tijdens de compilatiefase wordt ontdekt.

Je moet je hoop niet vestigen op de / Wp64-sleutel. Deze sleutel wordt vaak gepresenteerd als een prachtig middel om naar 64-bits fouten te zoeken. Eigenlijk kunt u met de sleutel /Wp64 eenvoudigweg enkele waarschuwingsberichten ontvangen over de onjuistheid van sommige delen van de code in de 64-bits modus, terwijl de 32-bits code wordt gecompileerd.

Bij het compileren van 64-bits code worden deze waarschuwingen nog steeds weergegeven. En daarom wordt de sleutel /Wp64 genegeerd bij het bouwen van een 64-bits applicatie. En deze sleutel zal zeker niet helpen bij het vinden van verborgen fouten. Laten we een aantal voorbeelden van verborgen fouten bekijken.

6.1. Expliciete typeconversie

De eenvoudigste soort fout (maar zeker niet de gemakkelijkst te detecteren) heeft betrekking op expliciete typeconversies, waarbij significante bits worden afgekapt. Een populair voorbeeld is het converteren van pointers naar 32-bits typen door ze door te geven aan functies zoals SendMessage:

Een applicatie bouwen

Hier wordt expliciete typeconversie gebruikt om een ​​pointer naar een numeriek type te converteren. Voor een 32-bits architectuur is dit voorbeeld correct, aangezien de laatste parameter van de SendMessage-functie het type LPARAM heeft, wat overeenkomt met DWORD op een 32-bits architectuur. Voor een 64-bits architectuur is DWORD onjuist en moet deze worden vervangen door LPARAM. Het LPARAM-type heeft een grootte van 32 of 64 bits, afhankelijk van de architectuur.

Dit is een eenvoudig geval, maar typeconversie lijkt vaak ingewikkelder en is onmogelijk te detecteren met behulp van compilerwaarschuwingen of het doorzoeken van de programmatekst. Expliciete typeconversies onderdrukken de diagnostiek van de compiler, omdat ze juist voor dit doel bedoeld zijn: de compiler vertellen dat de typeconversie correct is en dat de programmeur verantwoordelijk is voor de veiligheid van de code.

Expliciet zoeken helpt ook niet. Typen kunnen niet-standaardnamen hebben (gedefinieerd door de programmeur via typedef) en het aantal methoden om expliciete typeconversie uit te voeren is ook groot. Om deze fouten veilig te diagnosticeren, moet u een speciale set hulpmiddelen gebruiken, zoals Viva64- of PC-Lint-analysatoren.

6.2. Impliciete typeconversie

Het volgende voorbeeld heeft betrekking op impliciete typeconversie, waarbij ook belangrijke bits verloren gaan. De fread-functiecode leest het bestand, maar is onjuist wanneer wordt geprobeerd meer dan 2 GB te lezen op een 64-bits systeem.

Impliciete typeconversie

De functie __fread retourneert het size_t type, maar het int type wordt gebruikt om het aantal gelezen bytes op te slaan. Als gevolg hiervan kan de functie bij grote hoeveelheden gelezen gegevens een vals aantal bytes retourneren. Je kunt zeggen dat het ongeletterde code voor beginners is, dat de compiler dit type conversie zal aankondigen, en dat deze code heel gemakkelijk te vinden en te repareren is. Dit is in theorie.

In de praktijk kan bij grote projecten alles heel anders zijn. Dit voorbeeld is afkomstig uit de FreeBSD-broncode. De bug is in december 2008 opgelost! Merk op dat de eerste (experimentele) 64-bit versie van FreeBSD in juni 2003 werd uitgebracht.

6.3. Bits en veranderingen

Als u met afzonderlijke bits werkt, kunt u gemakkelijk een fout in uw code maken. Het volgende type fout heeft betrekking op ploegendiensten. Hier is een voorbeeld:

Bits en veranderingen

Deze code werkt prima op een 32-bits architectuur en stelt je in staat om bits van 0 tot en met 31 op 1 te zetten. Na het overzetten van het programma naar een 64-bits platform , moet je bits van 0 tot en met 63 instellen. Maar deze code zal bits 32-63 nooit instellen.

Merk op dat "1" van het type int is , en dat er bij een wijziging op positie 32 een overflow optreedt, zoals in de afbeelding te zien is. Of we als resultaat 0 (Figuur B) of 1 (Figuur C) krijgen, hangt af van de implementatie van de compiler.

Bits en veranderingen

Om de code te repareren, moeten we "1" constant maken van hetzelfde type als de maskervariabele:

ptrdiff_t masker = ptrdiff_t(1) << bitNum;

Let ook op het feit dat slechte code tot nog een fout leidt. Als u 31 bits instelt op een 64-bits systeem, is het resultaat van de functie de waarde 0xffffffff80000000. Het resultaat van de 1 << 31-expressie is het negatieve getal -2147483648. In een 64-bits geheel getalvariabele wordt dit getal weergegeven als 0xffffffff80000000.

Bits en veranderingen

6.4. magische getallen

Magische constanten – dat wil zeggen, getallen die worden gebruikt om de grootte van een bepaald type te definiëren – kunnen veel problemen veroorzaken. De juiste oplossing zou zijn om hiervoor de operator `sizeof()` te gebruiken, maar in een groot programma kan er nog steeds een verborgen gedeelte van oude code bestaan ​​waar, zoals programmeurs ten onrechte denken, de grootte van de pointer 4 bytes is, terwijl deze in `size_t` altijd 32 bits is. Deze fouten zien er doorgaans als volgt uit:

Magische cijfers

Hieronder staan ​​de basisnummers waarmee u voorzichtig moet zijn bij het overbrengen van programma's van 32-bit naar 64-bit.

Magische cijfers

Deze met de magische basiswaarden die gevaarlijk zijn bij het migreren van applicaties van een 32-bits naar 64-bits platform.

6.5. Fouten met betrekking tot het gebruik van 32-bits variabelen als indexen

In programma's die grote gegevens verwerken, kunnen fouten optreden die verband houden met het indexeren van grote arrays of eeuwige lussen. Het volgende voorbeeld bevat 2 fouten:

Fouten met betrekking tot het gebruik van 32-bits variabelen als indexen

De eerste fout hier is dat als de grootte van de te verwerken data groter is dan 4 GB (0xFFFFFFFF), er een oneindige lus kan ontstaan ​​omdat de variabele 'i' van het type ' unsigned ' is en nooit de waarde 0xFFFFFFFF zal bereiken. We hebben dit bewust zo geschreven, maar het hoeft niet per se te gebeuren. Het hangt af van de code die de compiler zal genereren.

In de debug-modus zal bijvoorbeeld de eeuwige lus aanwezig zijn, en in de releasecode zal er geen lus zijn, aangezien de compiler zal besluiten de code te optimaliseren met behulp van een 64-bits register voor de teller, en de lus zal correct zijn. Dit alles zorgt voor veel verwarring, en code die gisteren werkte, kan vandaag mislukken.

De tweede fout heeft betrekking op het doorlopen van de array van begin tot eind om te bepalen welke negatieve indexwaarden worden gebruikt. Deze code werkt prima in 32-bits modus, maar wanneer deze op een 64-bits computer wordt uitgevoerd, treedt er een out-of-bounds toegang tot de array op in de eerste iteratie van de lus, waardoor het programma vastloopt. Laten we de oorzaak van dit gedrag eens bekijken. Volgens de C++- regels wordt de expressie "-i - één" in een 32-bits systeem als volgt berekend: (in de eerste stap is i = 0):

De uitdrukking "-i" heeft een niet-ondertekend type en een waarde 0x00000000u.

De variabele ' one ' wordt uitgebreid van het type ' int ' naar het type 'unsigned' en zal gelijk zijn aan 0x00000001u. Opmerking: het type 'int' wordt (volgens de C++-standaard) uitgebreid naar het type ' unsigned ' als het deelneemt aan een bewerking waarbij het tweede argument van het type 'unsigned' is. Er wordt een aftrekking uitgevoerd met twee waarden van het type 'unsigned' , en het resultaat van de bewerking is 0x00000000u – 0x00000001u = 0xFFFFFFFFu. Merk op dat het resultaat van het type 'unsigned' zal zijn.

  Complete handleiding voor schijfversleuteling en het beschermen van gevoelige gegevens op NAS en pc.

In een 32-bits systeem is toegang tot de array via index 0xFFFFFFFFu hetzelfde als toegang via index -1. Dat wil zeggen, ` end[0xFFFFFFFFu]` is analoog aan `end[-1]`. Hierdoor worden de array-elementen correct verwerkt. In een 64-bits systeem is de situatie met betrekking tot dit laatste punt heel anders.

Het niet-ondertekende type wordt uitgebreid naar het ondertekende type ptfdiff_t, en de array-index wordt 0x00000000FFFFFFFFFi64. Hierdoor treedt een overflow op. Om de code te corrigeren, moet u de typen ptrdiff_t en size_t gebruiken.

6.6. Fouten gerelateerd aan het wijzigen van de gebruikte typen functies

Er zijn fouten die niemands schuld is, maar het zijn nog steeds fouten. Stel je voor dat heel, heel lang geleden in een sterrenstelsel ver weg (in Visual Studio 6.0) een project werd ontwikkeld met de CSampleApp-klasse, een opvolger van CWinApp. In de basisklasse bevindt zich een virtuele functie WinHelp. De opvolger overlapt deze functie en voert alle noodzakelijke acties uit. Dit proces wordt weergegeven in de volgende afbeelding.

Fouten gerelateerd aan het wijzigen van de gebruikte typen functies

Het project werd later verplaatst naar Visual Studio 2005, waar het prototype van de WinHelp-functie is veranderd, maar niemand merkte het omdat in de 32-bits modus de typen DWORD en DWORD_PTR overeenkwamen en het programma correct bleef werken.

Fouten gerelateerd aan het wijzigen van de gebruikte typen functies

De bug wacht om onthuld te worden op een 64-bits systeem, waar de typen DWORD en DWORD_PTR verschillende groottes hebben. Het blijkt dus dat de klassen in de 64-bitsmodus twee VERSCHILLENDE WinHelp-functies bevatten, wat beslist verkeerd is. Houd er rekening mee dat deze traps niet alleen verborgen kunnen zijn in MFC, waar sommige functies nu andere typen argumenten hebben, maar ook in de code van uw toepassingen en bibliotheken van derden.

6.7. Diagnose van verborgen fouten

Er zijn veel voorbeelden van dit soort 64-bits fouten. Zoals u kunt zien, is de fase van het zoeken naar verborgen fouten geen triviale taak, en bovendien zullen veel daarvan onregelmatig voorkomen en alleen bij grote gegevensinvoer. Statische code-analysatoren zijn goed in het diagnosticeren van dergelijke fouten, omdat ze de volledige code van een applicatie kunnen controleren, ongeacht de invoergegevens en de frequentie van uitvoering van de secties in reële omstandigheden.

Het is zinvol om statische analyse te gebruiken, zowel in de fase van het porten van een applicatie naar 64-bit-platforms, om de meeste fouten vanaf het allereerste begin te vinden, als bij de verdere ontwikkeling van 64-bit-oplossingen. Statische analyse zal een programmeur waarschuwen en leren de eigenaardigheden van fouten die verband houden met een 64-bits architectuur beter te begrijpen en efficiëntere code te schrijven.

Eerlijkheidshalve moeten we vermelden dat de code-analysatoren Gimpel PC-Lint en Parasoft C++ regelsets hebben voor het diagnosticeren van 64-bits fouten. Ten eerste zijn dit echter algemene analyseprogramma's en zijn hun regels voor het diagnosticeren van 64-bits fouten onvolledig. Ten tweede zijn ze primair ontworpen voor het LP64-datamodel dat wordt gebruikt in de Linux-besturingssystemen , waardoor ze niet erg bruikbaar zijn voor Windows-programma's die het LLP64-datamodel gebruiken.

Stap 7 – Testprocesupdate

De stap van het zoeken naar fouten in de programmacode, zoals beschreven in de vorige sectie, is noodzakelijk maar onvoldoende. Geen enkele methode, inclusief statische codeanalyse, kan garanderen dat alle fouten worden opgespoord. Het beste resultaat kan alleen worden bereikt door verschillende methoden te combineren.

Als uw 64-bits programma een grotere gegevensgrootte verwerkt dan de 32-bits versie, moet u de tests uitbreiden met verwerkingsgegevens groter dan 4 GB. Dit is de grens waarboven veel 64-bits fouten optreden. Deze tests kunnen veel langer duren en u moet hierop voorbereid zijn.

Tests zijn doorgaans zo geschreven dat elke test een klein aantal elementen kan verwerken en het zo mogelijk maakt om alle interne unit-tests in enkele minuten uit te voeren, terwijl geautomatiseerde tests (bijvoorbeeld met behulp van AutomatedQA TestComplete) in enkele uren kunnen worden voltooid.

De sorteerfunctie die 100 items sorteert, zal zich vrijwel zeker correct gedragen op 100000 items op een 32-bits systeem. Maar dezelfde functie kan mislukken op een 64-bits systeem wanneer wordt geprobeerd 5 miljard items te verwerken. De uitvoeringssnelheid van een unittest kan miljoenen keren worden verlaagd.

Vergeet de kosten van het aanpassen van tests niet terwijl u 64-bits systemen beheerst. Een goede oplossing is om unit-tests op te splitsen in snelle tests (die met kleine geheugengroottes werken) en langzame tests die gigabytes verwerken en bijvoorbeeld 's nachts worden uitgevoerd. Geautomatiseerd testen van resource-intensieve 64-bit programma's kan worden georganiseerd op basis van gedistribueerde berekeningen.

XNUMX% में antocianosios

Er is nog een onaangenaam aspect . Het is vrijwel onmogelijk om met tools zoals BoundsChecker bugs te vinden in resource-intensieve, geheugenverslindende 64-bits programma's. De reden hiervoor is de aanzienlijke vertraging die het veroorzaakt in de te testen programma's, waardoor deze aanpak zeer onpraktisch is.

In de diagnostische modus voor alle geheugengerelateerde fouten vertraagt ​​de Parallel Inspector- tool in Intel Parallel Studio de uitvoering van een applicatie gemiddeld met een factor 100. U zult het te testen algoritme waarschijnlijk een hele nacht moeten laten draaien om de resultaten de volgende dag te zien, terwijl dit algoritme normaal gesproken zijn cyclus in slechts 10 minuten voltooit.

Toch zijn we er zeker van dat Parallel Inspector een van de nuttigste en handigste hulpmiddelen is bij het werken in de foutopsporingsmodus voor geheugenbewerkingen. U hoeft alleen maar bereid te zijn uw praktijk voor foutdiagnose te veranderen en er rekening mee te houden wanneer u 64-bits systemen onder de knie wilt krijgen.

Diagnose van verborgen fouten

Bekijk ook: 10 beste Windows 10-reparatietools

Pensamientos finales

Vergeet niet tests toe te voegen die de compatibiliteit van gegevensformaten tussen 32-bits en 64-bits versies controleren. Gegevenscompatibiliteit wordt vaak geschonden tijdens migratie, vanwege schrijftypen zoals size_t of long (op Linux-systemen) naar bestanden. Dit is onze hele tutorial geweest over het overbrengen van programma's van 32-bit naar 64-bit. Wij hopen dat u een goede ervaring heeft gehad bij het voltooien van het proces.

Javier Chirinos

Javier Chirinos

Mijn naam is Javier Chirinos en ik ben gepassioneerd door technologie. Zolang ik me kan herinneren was ik dol op computers en videogames en die hobby mondde uit in een baan.

Ik publiceer al meer dan 15 jaar over technologie en gadgets op internet, vooral in mundobytes.com

Ik ben tevens een expert in online communicatie en marketing, en ik heb kennis van WordPress-ontwikkeling.