Denne artikkelen skisserer hovedtrinnene involvert i portering av programmer fra 32-biters til 64-biters systemer . Den beskriver de viktigste utfordringene utviklere som planlegger å migrere programmer fra 32-biters til 64-biters systemer står overfor. Selv om listen over problemstillinger som dekkes ikke er uttømmende, håper vi å kunne gi en mer detaljert versjon av denne artikkelen i fremtiden.
Overfør 32-biters programmer til 64-biters
Dette er trinnene for å migrere 32-biters Windows- programmer til 64-biters Windows-systemer:
Trinn 1: 64-biters modus kan være annerledes. La oss fikse det
I sammenheng med en datamaskinarkitektur refererer begrepet "64-bit" til 64-bits heltall og andre datatyper av denne størrelsen. "64-bits" systemer kan bety 64-bits mikroprosessorarkitekturer (f.eks. EM64T, IA-64) eller 64-bits operativsystemarkitekturer (f.eks. Windows XP Professional x64 Edition).
AMD64 (eller x86-64, Intel 64, EM64T, x64) er en 64-bits mikroprosessorarkitektur og tilhørende instruksjonssett utviklet av AMD. Dette instruksjonssettet ble lisensiert av Intel under navnet EM64T (Intel64). AMD64-arkitekturen er en utvidelse av x86-arkitekturen med full bakoverkompatibilitet.
Arkitekturen ble utbredt som grunnlag for personlige datamaskiner og arbeidsstasjoner. IA-64 er en 64-bits mikroprosessorarkitektur utviklet i fellesskap av Intel og Hewlett Packard-selskaper. Den er implementert på Itanium- og Itanium 2-mikroprosessorene. Arkitekturen brukes primært i multiprosessorservere og klyngesystemer.
Du kan også være interessert i: Slik laster du ned en PCI-enhet for Windows 7 64-bit
AMD64 og IA-64 er to forskjellige 64-bits arkitekturer som er inkompatible med hverandre. Derfor må utviklere bestemme om de trenger å støtte begge arkitekturene eller bare én. I de fleste tilfeller, med mindre du utvikler svært tilpasset programvare for klyngesystemer eller implementerer din egen høyytelses DBMS, vil du mest sannsynlig bare trenge å implementere støtte for AMD64-arkitekturen, som er mye mer populær enn IA -64.
Dette er spesielt programvare for PC-markedet, som er nesten 100 % okkupert av AMD64-arkitekturen. Senere i artikkelen vil vi bare snakke om AMD64 (EM64T, x64)-arkitekturen, siden den er den mest oppdaterte for applikasjonsprogramvareutviklere i dag. Når vi snakker om forskjellige arkitekturer, må vi nevne begrepet "Data Model".
Med datamodell mener vi korrelasjonene mellom aksepterte skriftstørrelser i utviklingsmiljøet. Flere utviklingsverktøy kan følge forskjellige datatyper for et operativsystem. Imidlertid er det vanligvis bare én modell, den som er tettest tilpasset maskinvare- og programvaremiljøet, som er dominerende.
Et eksempel på dette er 64-bits Windows, hvis originale datamodell er LLP64. Men av kompatibilitetsgrunner støtter 64-biters Windows å kjøre 32-biters programmer som opererer i ILP32LL-datamodellmodus. Tabell 1 gir informasjon om de grunnleggende datamodellene.
Datamodellen som brukes påvirker i stor grad utviklingsprosessen til 64-bits applikasjoner, siden størrelsen på dataene som brukes i programkoden må tas i betraktning.
Trinn 2: Finn ut om du trenger 64-bitsversjonen av produktet ditt
Du bør starte reisen din inn i 64-bits systemer ved å spørre deg selv: «Trenger jeg virkelig å bygge prosjektet mitt på nytt for et 64-bits system?» Svar bare på dette spørsmålet etter nøye overveielse. På den ene siden kan du falle bak konkurrentene dine hvis du ikke tilbyr 64-bits løsninger. På den andre siden kan du kaste bort tid på å utvikle et 64-bits program som ikke gir noen konkurransefordel. La oss liste opp de viktigste faktorene som vil hjelpe deg med å ta denne avgjørelsen.
2.1. Varighet for applikasjonens livssyklus
Du bør ikke lage 64-biters versjonen av en applikasjon med kort livssyklus. Takket være WOW64-undersystemet fungerer gamle 32-bits applikasjoner ganske bra på 64-bits Windows-systemer, og det er derfor det ikke er noen vits i å lage et 64-bitsprogram, siden det ikke vil bli støttet om 2 år.
I tillegg viser praksis at migreringen til 64-biters versjoner av Windows har blitt forsinket, og kanskje vil de fleste av brukerne kun bruke 32-bits versjonen av programløsningen på kort sikt.
Hvis du planlegger langsiktig utvikling og support av et programprodukt, bør du begynne å jobbe med 64-bits versjonen av løsningen din. Du kan gjøre dette uten å forhaste deg, men husk at jo lenger du ikke har en full 64-bit versjon, desto flere problemer vil du møte med å støtte denne applikasjonen installert på 64-bit versjoner av Windows.
2.2. Intensiv ressursbruk av en applikasjon
Å rekompilere et program for et 64-bits system vil tillate deg å bruke store størrelser hovedminne, og vil også øke hastigheten på driften med 5-15%. En økning på 5-10% vil bli oppnådd på grunn av bruken av de arkitektoniske egenskapene til 64-bits prosessor, for eksempel et høyere antall registre. Resten av hastighetsøkningen på 1-5 % forklares av fraværet av WOW64-laget, som oversetter API-anrop mellom 32-biters applikasjoner og et 64-biters operativsystem.
Hvis programmet ditt ikke håndterer store mengder data (over 2 GB) og hastigheten ikke er kritisk, vil det ikke være nødvendig å migrere til et 64-biters system i nær fremtid. Forresten, selv enkle 32-biters applikasjoner kan dra nytte av å kjøre i et 64-biters miljø.
Du vet kanskje at et program opprettet med nøkkelen / LARGEADDRESSAWARE: YES kan tildele opptil 3 GB minne hvis et 32-biters Windows-system startes med den nøkkelen. Det samme 32-biters programmet som startes på et 64-biters system kan tildele nesten 4 GB minne (i praksis rundt 3,5 GB).
2.3. Bibliotekutvikling
Hvis du utvikler biblioteker, komponenter eller andre elementer ved hjelp av tredjepartsutviklere som lager sin egen programvare, må du handle raskt mens du lager 64-bitsversjonen av produktet ditt. Ellers vil kunder som er interessert i å lansere 64-bit versjoner måtte se seg om etter alternative løsninger.
For eksempel reagerte noen programvare- og maskinvaresikkerhetsutviklere sakte ved å gi ut 64-biters programmer, og det fikk noen kunder til å se etter andre verktøy for å beskytte programmene sine.
En ekstra fordel med å utgi en 64-biters versjon av et bibliotek er at du kan selge det som et separat produkt . Derfor må kunder som ønsker å lage både 32-biters og 64-biters applikasjoner kjøpe to forskjellige lisenser.
2.4. Produktets avhengighet av tredjepartsbiblioteker
Før du planlegger arbeidet med å lage 64-bitsversjonen av produktet ditt, finn ut om 64-bitsversjoner av biblioteker og komponenter brukes. I tillegg til dette, kjenn til prispolitikken til 64-bitsversjonen av et bibliotek. Hvis støtte ikke tilbys, se etter alternative løsninger som støtter 64-bits systemer på forhånd.
2.5. Bruker 16-bits applikasjoner
Hvis løsningene dine fortsatt bruker 16-bits stasjoner, er det på tide å bli kvitt dem. 16-bits applikasjoner på 64-biters versjoner av Windows støttes ikke. Vi bør forklare en ting her om bruk av 16-biters installasjonsprogram. De brukes fortsatt til å installere noen 32-bits applikasjoner.
Det finnes en spesiell mekanisme som erstatter noen av de mest populære 16-bits installasjonsprogrammene med de nyeste versjonene. Dette kan føre til misforståelsen om at 16-bits programmer fortsatt fungerer i et 64-bits miljø . Husk: det gjør de ikke.
2.6. Kodemontering
Ikke glem at bruk av stor monteringskode kan øke kostnadene ved å lage 64-biters versjonen av en applikasjon betydelig. Etter å ha tenkt på alle faktorene som er oppført og veid alle fordeler og ulemper, bestem deg for om du trenger å overføre prosjektet til 64-bits systemer. Hvis svaret er ja, kan vi gå videre.
Trinn 3: Verktøysett
Hvis du har bestemt deg for å utvikle 64-biters versjonen av produktet ditt og er villig til å bruke tid, er det fortsatt ikke nok til å garantere suksess. Poenget er at du må ha hele det nødvendige settet med verktøy, og her kan du møte noen vanskeligheter. Fraværet av en 64-bits kompilator kan være det enkleste, men mest uoverkommelige problemet.
Hvis alt er klart om fraværet av en 64-bits kompilator, kan andre lignende problemer virke mindre gjennomsiktige og oppstå bare på stadiet for å portere prosjektet til en ny arkitektur. Derfor vil vi råde deg til å finne ut på forhånd om alle nødvendige komponenter finnes som du trenger for å implementere 64-biters versjonen av produktet ditt. Du kan møte ubehagelige overraskelser.
Selvfølgelig er det umulig å liste opp alt du trenger til et prosjekt her, men vi fortsetter med en liste som vil hjelpe deg, og kanskje minne deg på andre ting som er nødvendige for å implementere 64-bitersprosjektet ditt :
3.1. En 64-bits kompilator
Det er knapt mer å si om viktigheten av å ha en 64-bits kompilator. Det må rett og slett være sånn. Hvis du planlegger å utvikle 64-bits applikasjoner med den nyeste versjonen av Visual Studio, vil følgende tabell 2 hjelpe deg med å forstå hvilken utgave av Visual Studio du trenger.

3.2. 64-bits datamaskiner under kontroll av et 64-bits operativsystem
Selvfølgelig kan du bruke virtuelle maskiner til å kjøre 64-biters applikasjoner på 32-biters datamaskiner, men det er for tungvint og vil ikke gi det nødvendige testnivået. Ideelt sett bør maskinene ha minst 4–8 GB RAM.
3.3. 64-biters versjoner av alle biblioteker som brukes
Hvis biblioteker presenteres i kildekoder, må det være en 64-bits konfigurasjon av prosjektet. Det kan være en vanskelig og utakknemlig oppgave å oppdatere biblioteket for et 64-bitssystem på egen hånd, og resultatet kan være upålitelig og inneholde feil. I tillegg kan du bryte lisensavtaler med disse handlingene. Hvis du bruker biblioteker i form av binære stasjoner, bør du også finne ut om det finnes 64-bits stasjoner.
Du kan ikke bruke en 32-biters DLL i et 64-biters program . Du kan opprette en spesiell kobling via COM, men det vil være en separat, stor og vanskelig oppgave. Husk også at du kanskje må bruke litt ekstra penger på å kjøpe 64-biters versjonen av biblioteket.
3.4. Mangel på integrert monteringskode
Visual C++ støtter ikke en 64-bits inline assembler. Du må bruke en ekstern 64-bit assembler (f.eks. MASM) eller ha en implementering med samme funksjonalitet i C/C++.
3.5. Oppdatering av testmetodikk
Det betyr en betydelig ombygging av testmetodikken, oppdatering av enhetstester og bruk av nye verktøy. Vi vil snakke om dette mer detaljert senere, men ikke glem å ta det i betraktning på stadiet for å evaluere tidskostnadene ved å migrere en applikasjon til et nytt system.
3.6. Nye data å teste
Hvis du utvikler ressurskrevende applikasjoner som bruker en stor mengde hovedminne, bør du sørge for etterfylling av testinndatadatabase. Når du laster 64-bits applikasjoner, er det en god idé å overskride grensene på 4 GB for brukt minne. Mange feil kan bare oppstå under disse forholdene.
3.7. 64-biters sikkerhetssystemer
Sikkerhetssystemet som brukes må gi full kompatibilitet med 64-bits systemer. Det har ikke vært noe automatisk beskyttelsessystem for 64-bits binære filer (Hasp Envelop-programmet) på lenge.
Derfor måtte sikkerhetsmekanismen implementeres manuelt innenfor programkoden, og det var en vanskeligere oppgave som krevde profesjonalitet og tid. Ikke glem problemer knyttet til sikkerhet, systemoppdateringer, blant annet.
3.8. Installatør
Du trenger et nytt installasjonsprogram som kan installere 64-bits applikasjoner fullstendig. Vi vil gjerne advare deg om en veldig typisk feil. Det er opprettelsen av 64-biters installatører for å installere 32/64-bits programprodukter. Når de forbereder 64-biters versjonen av en applikasjon, ønsker utviklere ofte å gjøre "64-bits modus" absolutt og lage et 64-bits installasjonsprogram, og glemmer at de som bruker et 32-biters operativsystem rett og slett ikke kan starte en slik installasjonspakke.
Vær oppmerksom på at det ikke er 32-biters applikasjonen som er inkludert i distribusjonssettet sammen med 64-biters, men selve installasjonsprogrammet. For hvis distribusjonssettet er en 64-bits applikasjon, vil det selvfølgelig ikke fungere på et 32-bits operativsystem. Det mest ubehagelige er at en bruker ikke vil kunne gjette hvorfor det skjer.
Trinn 4: Sette opp et prosjekt i Visual Studio 2005/2008
Å lage 64-bits konfigurasjonen av et prosjekt i Visual Studio virker enkelt nok. Vanskeligheter vil begynne på stadiet med å bygge en ny konfigurasjon og finne feil i den. For å lage selve 64-bits oppsettet, må du utføre følgende 4 trinn:
Trinn 1: Start konfigurasjonsbehandleren, som vist i bilde 1:

Trinn 2: I konfigurasjonsbehandleren velger du støtte for den nye plattformen:

Trinn 3: Velg 64-biters (x64) plattform og, som utgangspunkt, 32-biters versjonsinnstillinger. Visual Studio vil automatisk korrigere eventuelle innstillinger som påvirker byggemodus.

Trinn 4: Tillegget av en ny konfigurasjon er fullført, og du kan nå velge 64-biters konfigurasjonsversjon og begynne å kompilere et 64-biters program. Valget av 64-biters konfigurasjon for bygging vises i figur 4.

Hvis du er heldig, trenger du ikke å konfigurere et 64-biters prosjekt ytterligere. Men det avhenger i stor grad av prosjektet, dets kompleksitet og antall biblioteker som brukes. Det eneste du trenger å endre samtidig er stakkstørrelsen. Hvis stakkstørrelsen i prosjektet ditt er satt til standardverdien 1 MB, må du sette den til 2 MB for 64-biters versjonen.
Det er ikke påkrevd, men det er best å være sikker på det på forhånd. Hvis du bruker en annen størrelse enn standarden, er det fornuftig å øke den med to for 64-bitersversjonen. For å gjøre dette, finn og endre parameterne Stack Reserve Size og Stack Commit Size i prosjektinnstillingene dine.
Trinn 5: Bygg en applikasjon
Her bør vi fortelle deg om de typiske problemene som oppstår i kompileringsfasen av 64-bits konfigurasjon, diskutere hvilke problemer som oppstår i tredjepartsbiblioteker, fortelle deg at i koden relatert til WinAPI-funksjoner, vil kompilatoren ikke tillate å plassere en peker i skriv LONG, og du må oppdatere koden din og bruke typen LONG_PTG. Og det er mye mer å si.
Dessverre er det så mange problemer og feilene varierer så mye at vi ikke kan beskrive dem alle i én artikkel, eller til og med i én bok. Du må gjennomgå alle feilene som kompilatoren viser deg og alle de nye advarslene som ikke var der før, og i hvert enkelt tilfelle finne ut hvordan du oppdaterer koden.
La oss her kun beskrive de typene som kan være av interesse for utviklere ved portering av applikasjoner. De fleste rekompileringsfeil vil være relatert til bruk av disse samme typene:
- Ved t 32/32: grunnleggende type. På 64-bits systemer er det fortsatt 32-bit.
- Lang 32/32: grunnleggende type. På 64-bits Windows-systemer er det fortsatt 32-bit. Vær oppmerksom på at i systemer Linux 64-bit, denne typen ble utvidet til 64-bit. Ikke glem dette hvis du utvikler kode som skal kompileres for Windows- og Linux-systemer.
- størrelse_t 32 / 64: usignert grunntype. Størrelsen på typen er valgt på en slik måte at du kan skrive den maksimale størrelsen på en matrise som er teoretisk mulig. Du kan trygt sette en peker til å skrive size_t (bortsett fra pekere til klassefunksjoner, men dette er et spesielt tilfelle).
- ptrdiff_t 32 / 64: ligner på size_t-typen, men dette er en signert type. Resultatet av uttrykket der en peker trekkes fra den andre (ptr1-ptr2) vil ha typen ptrdiff_t.
- Peker 32/64: Størrelsen på pekeren avhenger direkte av størrelsen på plattformen. Vær forsiktig når du konverterer pekere til andre typer.
- __int64 64 / 64: 64-bits signert type.
- DWORD 32/32: 32-bits usignert type. I WinDef.h er det definert som: typedef unsigned long DWORD;
- DWORDLONG 64/64: 64-bits usignert type. I WinNT.h er det definert som: typedef ULONGLONG DWORDLONG.
- DWORD_PTR 32/64: usignert type som en peker kan plasseres i. I BaseTsd.h er det definert som: typedef ULONG_PTR DWORD_PTR.
- DWORD32 32 / 32: 32-bits usignert type. I BaseTsd.h er det definert som: typedef unsigned int DWORD32.
- DWORD64 64 / 64: 64-bits usignert type. I BaseTsd.h er det definert som: typedef unsigned __int64 DWORD64.
- HALF_PTR 16 / 32: en halv peker. I Basetsd.h er det definert som: #ifdef _WIN64. typedef int HALF_PTR; #else typedef kort HALF_PTR; #endif
- INT_PTR 32 / 64: signert type som en peker kan plasseres til. I BaseTsd.h er det definert som: #if definert (_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR; #endif
- Lang 32/32: signert type som forble 32-bit. Derfor bør LONG_PTR i mange tilfeller nå brukes. I WinNT.h er det definert som: typedef long LONG;
- LONG_PTR 32 / 64: signert type som en peker kan plasseres til. I BaseTsd.h er det definert som: #if definert (_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR; #endif.
- LPARAM 32 / 64: parameter for å sende meldinger. I WinNT.h er det definert som: typedef LONG_PTR LPARAM.
- SIZE_T 32 / 64: analog av typen size_t. I BaseTsd.h er det definert som: typedef ULONG_PTR SIZE_T.
- SSIZE_T 32/64: Analog av typen ptrdiff_t. I BaseTsd.h er det definert som: typedef LONG_PTR SSIZE_T.
- ULONG_PTR 32 / 64: usignert type som en peker kan plasseres i. I BaseTsd.h er det definert som: #if definert (_WIN64) typedef unsigned __int64 ULONG_PTR; #else typedef usignert lang ULONG_PTR; #endif.
- WORD 16/16: Usignert 16-bits type. I WinDef.h er det definert som: typedef unsigned short WORD.
- WPARAM 32/64: parameter for å sende meldinger. I WinDef.h er det definert som: typedef UINT_PTR WPARAM.
Dette er typene du bør vurdere når du migrerer 32-biters programmer til 64-biters Windows-systemer.
Du vil kanskje også vite: Slik bruker du all RAM i Windows 10
6. Diagnostisering av skjulte feil
Hvis du tror at etter å ha fikset alle kompilasjonsfeilene vil du få en etterlengtet 64-bit applikasjon, må vi skuffe deg. Den vanskeligste delen er ennå ikke kommet. På kompileringsstadiet vil den rette opp de mest eksplisitte feilene som kompilatoren har klart å oppdage, og som stort sett er relatert til umuligheten av implisitt typekonvertering.
Men dette er bare en liten del av problemet. De fleste feilene er skjult. Fra synspunktet til det abstrakte språket C++, virker disse feilene trygge og er skjult av eksplisitte typekonverteringer. Antallet slike feil er mye høyere enn antallet feil oppdaget på kompileringsstadiet.
Du bør ikke sette håp på / Wp64-tasten. Denne nøkkelen presenteres ofte som et fantastisk middel til å søke etter 64-biters feil. Faktisk lar /Wp64-nøkkelen deg ganske enkelt motta noen advarselsmeldinger om feilen til enkelte kodeseksjoner i 64-biters modus, mens 32-biters koden blir kompilert.
Når du kompilerer 64-biters kode, vil disse advarslene fortsatt vises. Og det er derfor /Wp64-nøkkelen ignoreres når du bygger en 64-bits applikasjon. Og denne nøkkelen vil sikkert ikke hjelpe med å finne skjulte feil. La oss vurdere flere eksempler på skjulte feil.
6.1. Eksplisitt typekonvertering
Den enkleste typen feil (men absolutt ikke den enkleste å oppdage) er relatert til eksplisitte typekonverteringer, når betydelige biter kuttes. Et populært eksempel er å konvertere pekere til 32-bits typer ved å sende dem til funksjoner som SendMessage:

Her brukes eksplisitt typekonvertering for å konvertere en peker til en numerisk type. For en 32-bits arkitektur er dette eksemplet riktig siden den siste parameteren i SendMessage-funksjonen har typen LPARAM, som samsvarer med DWORD på en 32-bits arkitektur. For en 64-bits arkitektur er DWORD feil og bør erstattes med LPARAM. LPARAM-typen har størrelser på 32 eller 64 biter, avhengig av arkitekturen.
Dette er et enkelt tilfelle, men typekonvertering virker ofte mer komplisert og er umulig å oppdage ved å bruke kompilatoradvarsler eller søke i programteksten. Eksplisitte typekonverteringer undertrykker kompilatordiagnostikk, siden de er ment for nettopp dette formålet: å fortelle kompilatoren at typekonverteringen er korrekt og at programmereren er ansvarlig for sikkerheten til koden.
Eksplisitt søk hjelper heller ikke. Typer kan ha ikke-standardnavn (definert av programmereren via typedef), og antallet metoder for å utføre eksplisitt typekonvertering er også stort. For å diagnostisere disse feilene på en sikker måte, må du bruke et spesielt sett med verktøy, for eksempel Viva64- eller PC-Lint-analysatorer.
6.2. Implisitt typekonvertering
Følgende eksempel gjelder implisitt typekonvertering, når viktige biter også går tapt. Fread-funksjonskoden leser filen, men er feil når du prøver å lese mer enn 2 GB på et 64-bitssystem.

__fread-funksjonen returnerer size_t-typen, men int-typen brukes til å lagre antall leste byte. Som et resultat, ved store datastørrelser kan funksjonen returnere et falskt antall byte. Du kan si at det er analfabet kode for nybegynnere, at kompilatoren vil kunngjøre denne typen konvertering, og at denne koden er veldig enkel å finne og fikse. Dette er i teorien.
I praksis kan alt være ganske annerledes ved store prosjekter. Dette eksemplet er hentet fra FreeBSD-kildekoden. Feilen ble rettet i desember 2008! Merk at den første (eksperimentelle) 64-biters versjonen av FreeBSD ble utgitt i juni 2003.
6.3. Biter og endringer
Det er lett å gjøre en feil i koden mens du arbeider med separate biter. Den neste typen feil er knyttet til skiftoperasjoner. Her er et eksempel:

Denne koden fungerer fint på en 32-bits arkitektur og lar deg sette biter fra 0 til 31 til 1. Etter at du har portert programmet til en 64-bits plattform , må du sette biter fra 0 til 63. Men denne koden vil aldri sette biter 32–63.
Merk at «1» er av typen int , og når en endring skjer i 32 posisjoner, vil det oppstå et overløp som vist på bildet. Om vi får 0 (figur B) eller 1 (figur C) som resultat avhenger av kompilatorimplementeringen.

For å fikse koden, må vi gjøre "1" konstant av samme type som maskevariabelen:
ptrdiff_t mask = ptrdiff_t(1) << bitNum;
Vær også oppmerksom på at dårlig kode fører til en feil til. Når du setter 31 biter på et 64-bit system, vil resultatet av funksjonen være verdien 0xffffffff80000000. Resultatet av 1 << 31 uttrykk er det negative tallet -2147483648. I en 64-bits heltallsvariabel presenteres dette tallet som 0xffffffff80000000.

6.4. magiske tall
Magiske konstanter – det vil si tall som brukes til å definere størrelsen på en bestemt type – kan forårsake mange problemer. Den riktige løsningen ville være å bruke `sizeof()`-operatorer til dette formålet, men i et stort program kan det fortsatt finnes en skjult del av gammel kode der, som programmerere feilaktig tror, pekerens størrelse er 4 byte, mens den i `size_t` alltid er 32 bits. Disse feilene ser vanligvis slik ut:

Nedenfor er de grunnleggende tallene du bør være forsiktig med når du overfører programmer fra 32-bit til 64-bit.

Disse med de grunnleggende magiske verdiene som er farlige ved migrering av applikasjoner fra en 32-biters til 64-biters plattform.
6.5. Feil relatert til bruk av 32-bits variabler som indekser
I programmer som behandler store data, kan det oppstå feil relatert til indeksering av store arrays eller evige looper. Følgende eksempel inneholder 2 feil:

Den første feilen her er at hvis størrelsen på dataene som behandles overstiger 4 GB (0xFFFFFFFF), kan det oppstå en uendelig løkke fordi variabelen 'i' har typen ' unsigned ' og aldri vil nå verdien 0xFFFFFFFF. Vi skrev bevisst at det kan skje, men det gjør det ikke nødvendigvis. Det avhenger av koden kompilatoren bygger.
For eksempel, i feilsøkingsmodus vil den evige sløyfen være til stede, og i utgivelseskoden vil det ikke være noen løkke da kompilatoren vil bestemme seg for å optimalisere koden ved å bruke et 64-bits register for telleren, og sløyfen vil være korrekt. Alt dette legger til mye forvirring, og kode som fungerte i går kan mislykkes i dag.
Den andre feilen gjelder å analysere arrayet fra begynnelse til slutt for å bestemme hvilke negative indeksverdier som brukes. Denne koden vil fungere fint i 32-biters modus, men når den kjøres på en 64-biters datamaskin, vil det oppstå tilgang utenfor grensene til arrayet i den første iterasjonen av løkken, og programmet vil krasje. La oss undersøke årsaken til denne oppførselen. I henhold til C++- regler vil uttrykket "-i - en" i et 32-biters system beregnes som følger: (i det første trinnet, i = 0):
Uttrykket "-i" har en usignert type og en verdi 0x00000000u.
Variabelen « one » vil bli utvidet fra typen « int » til den usignerte typen og vil være lik 0x00000001u. Merk: int - typen utvides (i henhold til C++-standarden) til typen « unsigned » hvis den deltar i en operasjon der det andre argumentet har en usignert type. En subtraksjonsoperasjon utføres som involverer to usignerte verdier , og resultatet av operasjonen er 0x00000000u – 0x00000001u = 0xFFFFFFFFu. Merk at resultatet vil ha en usignert type.
I et 32-bits system er det samme å få tilgang til arrayet via indeks 0xFFFFFFFFu som å bruke indeks -1. Det vil si at ` end[0xFFFFFFFFu]` er analogt med `end[-1]`. Som et resultat vil arrayelementene bli behandlet riktig. I et 64-bits system vil situasjonen være ganske annerledes med hensyn til det siste punktet.
Den usignerte typen vil bli utvidet til den signerte typen ptfdiff_t, og arrayindeksen vil være 0x00000000FFFFFFFFi64. Som et resultat vil det oppstå et overflyt. For å korrigere koden må du bruke typene ptrdiff_t og size_t.
6.6. Feil knyttet til endring av typene funksjoner som brukes
Det er feil som ikke er noens feil, men de er likevel feil. Tenk deg at det for lenge, lenge siden i en galakse langt unna (i Visual Studio 6.0), ble utviklet et prosjekt som inneholder CSampleApp-klassen, en etterfølger til CWinApp. I basisklassen er det en WinHelp virtuell funksjon. Etterfølgeren legger over denne funksjonen og utfører alle nødvendige handlinger. Denne prosessen er vist i følgende figur.

Prosjektet ble senere flyttet til Visual Studio 2005, hvor prototypen til WinHelp-funksjonen har endret seg, men ingen la merke til det fordi DWORD- og DWORD_PTR-typene matchet i 32-biters modus og programmet fortsatte å fungere korrekt.

Feilen venter på å bli avslørt på et 64-bits system, der typene DWORD og DWORD_PTR har forskjellige størrelser. Så det viser seg at i 64-bits modus inneholder klassene to ULIKE WinHelp-funksjoner, noe som sikkert er feil. Merk at disse fellene kan skjules ikke bare i MFC, der noen av funksjonene nå har andre typer argumenter, men også i koden til applikasjonene og tredjepartsbibliotekene dine.
6.7. Diagnostisering av skjulte feil
Det er mange eksempler på denne typen 64-biters feil. Som du kan se, er stadiet med å søke etter skjulte feil ikke en triviell oppgave, og dessuten vil mange av dem forekomme uregelmessig og bare med store datainndata. Statiske kodeanalysatorer er gode til å diagnostisere slike feil, siden de kan sjekke hele koden til en applikasjon uavhengig av inngangsdata og frekvensen av utførelse av dens seksjoner under reelle forhold.
Det er fornuftig å bruke statisk analyse både på stadiet med å portere en applikasjon til 64-biters plattformer, for å finne de fleste feilene helt fra begynnelsen, og i videreutviklingen av 64-bits løsninger. Statisk analyse vil advare og lære en programmerer å bedre forstå særegenhetene ved feil relatert til en 64-bits arkitektur og å skrive mer effektiv kode.
For å være rettferdig bør vi nevne at Gimpel PC-Lint og Parasoft C++-kodeanalysatorene har regelsett for diagnostisering av 64-bits feil. For det første er disse imidlertid generelle analysatorer, og deres 64-bits feildiagnostiske regler er ufullstendige. For det andre er de primært designet for LP64-datamodellen som brukes i Linux-familien av operativsystemer , så de er ikke veldig nyttige for Windows-programmer som bruker LLP64-datamodellen.
Trinn 7 – Testprosessoppdatering
Trinnet med å søke etter feil i programkoden beskrevet i forrige avsnitt er nødvendig, men utilstrekkelig. Ingen av metodene, inkludert statisk kodeanalyse, kan garantere at alle feil oppdages, og det beste resultatet kan bare oppnås ved å kombinere forskjellige metoder.
Hvis 64-biters programmet ditt behandler en større datastørrelse enn 32-bitsversjonen, bør du utvide testene til å inkludere behandlingsdata som er større enn 4 GB. Dette er grensen for mange 64-biters feil begynner å oppstå. Disse testene kan ta mye lengre tid, og du bør være forberedt på dette.
Tester skrives vanligvis på en slik måte at hver test kan behandle et lite antall elementer og dermed gjøre det mulig å utføre alle interne enhetstester på flere minutter, mens automatiserte tester (f.eks. ved hjelp av AutomatedQA TestComplete) kan gjennomføres på flere timer.
Sorteringsfunksjonen som sorterer 100 elementer vil nesten helt sikkert oppføre seg riktig på 100000 32 elementer på et 64-bitssystem. Men den samme funksjonen kan svikte på et 5-bits system når man prøver å behandle XNUMX milliarder elementer. Utførelseshastigheten til en enhetstest kan reduseres med millioner av ganger.
Ikke glem kostnadene ved å tilpasse tester mens du mestrer 64-bits systemer. En god løsning er å dele opp enhetstester i raske (arbeider med små minnestørrelser) og trege som behandler gigabyte og kjører for eksempel over natten. Automatisert testing av ressurskrevende 64-bits programmer kan organiseres basert på distribuerte beregninger.
advarsler
Det er enda et ubehagelig aspekt . Du vil neppe lykkes med å bruke verktøy som BoundsChecker til å finne feil i ressurskrevende, minnekrevende 64-bits programmer. Årsaken er den betydelige nedgangen det forårsaker i programmene som testes, noe som gjør denne tilnærmingen svært upraktisk.
I diagnostisk modus for alle minnerelaterte feil, vil Parallel Inspector- verktøyet som er inkludert i Intel Parallel Studio , redusere hastigheten på en applikasjons kjøring med gjennomsnittlig 100 ganger. Du må sannsynligvis la algoritmen under test kjøre over natten for å se resultatene først dagen etter, mens denne algoritmen vanligvis fullfører syklusen sin på bare 10 minutter.
Likevel er vi sikre på at Parallel Inspector er et av de mest nyttige og praktiske verktøyene når du arbeider i minneoperasjonsfeilsøkingsmodus. Du trenger bare å være forberedt på å endre din feildiagnosepraksis og ta den i betraktning når du planlegger å mestre 64-bits systemer.

Siste tanker
Ikke glem å legge til tester som sjekker dataformatkompatibilitet mellom 32-biters og 64-biters versjoner. Datakompatibilitet blir ofte krenket under migrering, på grunn av skrivetyper som size_t eller long (på Linux-systemer) til filer. Dette har vært hele opplæringen vår om hvordan du overfører programmer fra 32-bit til 64-bit. Vi håper du hadde en god opplevelse når du fullførte prosessen.
Indeks
- 1 Overfør 32-biters programmer til 64-biters
- 1.1 Trinn 1: 64-biters modus kan være annerledes. La oss fikse det
- 1.2 Trinn 2: Finn ut om du trenger 64-bitsversjonen av produktet ditt
- 1.3 2.5. Bruker 16-bits applikasjoner
- 1.4 2.6. Kodemontering
- 1.5 Trinn 3: Verktøysett
- 1.5.1 3.1. En 64-bits kompilator
- 1.5.2 3.2. 64-bits datamaskiner under kontroll av et 64-bits operativsystem
- 1.5.3 3.3. 64-biters versjoner av alle biblioteker som brukes
- 1.5.4 3.4. Mangel på integrert monteringskode
- 1.5.5 3.5. Oppdatering av testmetodikk
- 1.5.6 3.6. Nye data å teste
- 1.5.7 3.7. 64-biters sikkerhetssystemer
- 1.5.8 3.8. Installatør
- 1.6 Trinn 4: Sette opp et prosjekt i Visual Studio 2005/2008
- 1.7 Trinn 5: Bygg en applikasjon
- 1.8 6. Diagnostisering av skjulte feil
- 1.8.1 6.1. Eksplisitt typekonvertering
- 1.8.2 6.2. Implisitt typekonvertering
- 1.8.3 6.3. Biter og endringer
- 1.8.4 6.4. magiske tall
- 1.8.5 6.5. Feil relatert til bruk av 32-bits variabler som indekser
- 1.8.6 6.6. Feil knyttet til endring av typene funksjoner som brukes
- 1.8.7 6.7. Diagnostisering av skjulte feil
- 1.9 Trinn 7 – Testprosessoppdatering
- 2 Siste tanker