De flesta moderna spel som Overwatch, Hurtworld eller Subnautica kan bara köras på 64-bitars operativsystem. Det är helt enkelt inte lönsamt för skaparna av dessa program att göra olika versioner av applikationer för 32- och 64-bitars. Även om båda versionerna är ganska vanliga. Naturligtvis är det ganska enkelt att byta till x64. Men vad händer om du inte ska ändra OS och ändå vill se ett populärt spel? Lär dig hur du kör Subnautica och andra 64-bitarsprogram på ett 32-bitarssystem.

För att göra detta måste datorn uppfylla de krav som krävs för normal drift av applikationen. Processorn måste initialt ha x64-arkitektur.

Vad är skillnaden mellan ett 32-bitarssystem och ett 64-bitars system?

Varför kan inte program som är designade för 64 bitar öppnas i 32 bitar? Varför är dessa versioner så olika, eftersom de inte kör samma applikationer? Och om Overwatch kan spelas på x64, varför kan det inte spelas på samma dator, men med x32?

Det beror på systemet hur mycket RAM som kan installeras på en PC och hur mycket den kan allokera till varje specifik applikation. I x64 är den maximala mängden RAM 16 GB (i Windows 7 Professional - upp till 192 GB). I det här fallet tillhandahålls alla verktyg med upp till 4 GB. I x32-versionen är de angivna siffrorna mycket mindre - max 4 GB och 2 GB för ett separat program.

Processorns kapacitet avgör hur den behandlar information. Detta påverkar avsevärt prestandan - det är mycket bättre i 64 bitar. Det finns ett större register för att lagra data, och belastningen fördelas över alla kärnor på en gång. Och i ett 32-bitars operativsystem aktiveras den andra kärnan när den första är fullt upptagen.

Installera x32 på "svaga" maskiner. Om din dator inte har mycket RAM och inte har den bästa processorn, är det helt enkelt ingen idé att köra 64 bitar. Detta kommer bara att "överbelasta" den elektroniska datorn utan att öka produktiviteten till den. Men en kraftfull x64-dator kommer att vara helt rätt.

Även om dessa system ytligt liknar varandra är de väldigt olika på mjukvarunivå. De har en annan uppsättning drivrutiner, så Subnautica, Overwatch, Hurtworld och andra liknande kommer inte att köras på ett 32-bitars OS, även om datorn har de nödvändiga egenskaperna.

För moderna spel, applikationer, grafik eller videoredigeringsprogram räcker inte de 2 GB som x32 tilldelar dem. Kompositörer av nya spel skapar sina produkter specifikt för x64.

Hur tar man reda på om en processor stöder x64?

Du kan se vilket OS du har installerat så här:

1. Högerklicka på ikonen "Den här datorn" på skrivbordet.
2. "Egenskaper". Den kan också hittas i avsnittet Kontrollpanel.
3. Raden "Typ" kommer att indikera hur många bitar det finns i din OS-version.

Först måste du förstå vilket system du arbetar med.

Innan du kör Overwatch på ett 32-bitarssystem, ta reda på om din dator kan hantera spelet. Kontrollera om processorn stöder 64-bitars instruktioner. Detta kan göras med hjälp av speciella testprogram. Till exempel är gratisverktyget "SecurAble" lämpligt. Det behöver inte installeras. Och följaktligen finns det inget behov av att ta bort det efter användning. Kör bara den körbara filen. Information om processorn kommer att visas: namn, klockhastighet, bitdjup, om den stöder D.E.P (detta är skyddet av enheten mot buffertspill) och hårdvaruvisualisering. Du kan klicka på något av resultaten och dess beskrivning visas.

Kontrollerar processorstöd för 64-bitars kommandon

Om programmet returnerar en dom på "Maximum 32 bitar" betyder det att applikationer designade för x64 sannolikt inte kommer att fungera. För att spela Overwatch eller Hurtword måste du byta processor eller göra dig av med fjärrservrar.

Hur förvandlar man ett 32-bitarssystem till ett 64-bitars?

Det finns flera verktyg för så kallad virtualisering. De emulerar driften av en plattform med viss mjukvara och hårdvara. Om du behöver ta reda på hur du kör Hurtworld på ett 32-bitarssystem, använd ett av dessa verktyg.

Dessa program skapar ett slags "gäst" OS. Men du måste installera den i alla fall och köpa en licensierad version om den är betald. För att göra detta måste du ha en disk (eller diskavbildning) med det operativsystem du behöver.

Oracle VirtualBox

Ett universellt program för liknande uppgifter.

1. Installera den och kör den. Till vänster kommer det att finnas en lista över installerade operativsystem och ett verktygsfält. Till höger finns information om det valda systemet.
2. Klicka på knappen "Skapa". Ett informationsfönster visas. Klicka på "Nästa".
3. Välj OS-typ och version. Det finns många alternativ att välja mellan: inte bara Microsoft Windows utan även Linux.
4. Sedan måste du bestämma hur mycket RAM-minne du ska allokera till "gäst"-systemet.
5. Efter detta måste du skapa en virtuell disk (till vilken OS-filerna kommer att skrivas). Du kan välja en befintlig eller skapa en ny. Och markera rutan bredvid alternativet "Boot disk".
6. I nästa fönster väljer du om diskkapaciteten ska vara fast eller dynamisk (förändras). Det finns detaljerade förklaringar för varje punkt. Det är bättre att göra stöveln en fast. Du kan lägga till fler enheter senare.
7. Konfigurera storleken på den virtuella lagringen. Vanligtvis räcker 10 GB. Det är bättre att skapa det på en separat plats - inte på samma plats där huvudsystemet är installerat.
8. Vänta tills processen är klar. En ny kommer att dyka upp i listan över tillgängliga.

Ett sätt är att använda virtualiseringsverktyg

Efteråt kan du konfigurera hårdvaran:

1. Välj gäst-OS och klicka på Egenskaper.
2. I avsnittet Allmänt - Avancerat ändrar du mappen för att spara bilder till den som passar dig.
3. Sätt upp urklippet där. Det bestämmer hur information ska överföras mellan olika operativsystem.
4. På fliken "System" kan du välja egenskaperna för det virtuella moderkortet och processorn.
5. Alternativet "Nätverk" behövs för att konfigurera åtkomst till World Wide Web. Du kan lämna standardinställningarna.
6. I avsnittet "Media" anger du var du vill hämta operativsystemet ifrån. Om installationsprogrammet finns på en CD, sätt in det i din enhet. För att ladda ner från .ISO, klicka på "Öppna"-knappen bredvid "Drive"-listan. Det ser ut som en gul mapp.
7. Du kan också lägga till andra bilder där för att snabbt växla mellan dem: databaser, applikationer, spel.

När du har slutfört inställningarna klickar du på "OK". För att starta gästoperativsystemet, klicka på det och "Start"-knappen. Installationen kommer att fortsätta. Och du kan växla mellan system: spela i 64-bitars och arbeta i 32-bitars.

Andra virtuella maskiner

Det finns också verktyg för att arbeta med virtuella maskiner:

• VMware arbetsstation. Ett seriöst professionellt program för komplexa uppgifter. Den delas ut på betald basis.
• Ett enkelt verktyg för hårdvaruemulering. Det är öppen källkod.
• Windows Virtual PC. Fungerar endast med Windows-system. Du kan konfigurera prioriteringen av processer - på detta sätt kommer resurser automatiskt att allokeras till onlinemaskinen om den utför en viss uppgift.
• Virt-Manager. Ger stora möjligheter att anpassa hårdvarukomponenten - virtuell hårdvara finns tillgänglig för alla smaker.

Cloud computing (fjärrservrar)

Om prestandan fortfarande inte räcker till för att köra spelet kan du göra det på en fjärrserver. Alla beräkningar, all information kommer att behandlas på den. På så sätt kommer du inte att hindras av några begränsningar förknippade med x32. När allt kommer omkring, i huvudsak kommer applikationer att "öppnas" på lämpliga system. Bara inte på din dator.

Microsoft Azure-programmet är lämpligt för detta. Med dess hjälp kan du skapa flera operativsystem för olika ändamål. Spelälskare kommer också att finna den specialiserade NVIDIA GRID-videokortsvirtualiseringstjänsten användbar. Dessa verktyg kräver höghastighetsinternet.

Banbrytande molntjänster utökar våra möjligheter

Att arbeta med 64-bitars applikationer på ett 32-bitarssystem är fullt möjligt. Men du måste installera ytterligare programvara eller i allmänhet byta till en fjärrserver. Detta är ganska svårt att göra. Om du vill spela Overwatch, Hurtword och andra populära spel fullt ut är det bättre att installera x64 OS. På så sätt blir det inga kompatibilitetsproblem. Och du behöver inte konfigurera någonting.

NastroyVse.ru

Windows x64 - Varför finns det fortfarande så många 32-bitarsprogram?

Din dator kör troligen en 64-bitarsversion av Windows. Men om du öppnar Aktivitetshanteraren kommer du att se att de flesta av programmen på ditt system fortfarande är 32-bitars. Är detta verkligen ett problem? Det finns många skillnader mellan 64-bitars och 32-bitarsversioner av Windows. 64-bitarsversioner av Windows kan köra 32-bitars programvara, men 32-bitarsversioner av Windows kan inte köra 64-bitars programvara.

Hur tar man reda på bitdjupet i ett program?

Låt oss använda Aktivitetshanteraren för att se vilka av dina program som är 64-bitars och vilka som är 32-bitars. Högerklicka på aktivitetsfältet och välj Aktivitetshanteraren eller tryck på Ctrl + Skift + Esc för att öppna den. Titta på kolumnen med processnamn. Om du använder 64-bitarsversionen av Windows 8.1 eller 8, kommer du att se ordet "(32-bitars)" efter varje 32-bitarsversion av programnamnet. Om du använder 64-bitarsversionen av Windows 7 kommer du att se "*32" istället. 32-bitarsprogram installeras vanligtvis i mappen C:\Program Files (x86)\ på 64-bitarsversioner av Windows, medan 64-bitarsprogram vanligtvis installeras i mappen C:\Program Files\. Det är bara en regel. Men ingen säger att det inte finns någon annan regel som förbjuder installation av 64-bitarsprogram i mappen C:\Program Files (x86)\. Till exempel är Steam ett 32-bitarsprogram, så det installeras i "C:\Program Files (x86)\" som standard. Spelen du installerar på Steam installeras som standard i mappen C:\Program Files (x86)\Steam, inkl. även 64-bitarsversioner av spel. Om du jämför två olika Program Files-mappar kommer du att upptäcka att de flesta av dina program troligen är installerade i mappen C:\Program Files (x86). Och dessa program är oftast 32-bitars.

Kör 32-bitars programvara på ett 64-bitars operativsystem

Vid första anblicken verkar det hemskt att de flesta av dina Windows-program inte använder 64-bitars operativsystemarkitektur. Du kanske tror att det finns en prestationsstraff för att köra 32-bitarsprogram på ett 64-bitars operativsystem, men så är inte fallet. Windows kör 32-bitarsprogram genom WoW64-kompatibilitetsnivån på 64-bitarsversioner av Windows. 64-bitars Intel- och AMD-processorer är dock bakåtkompatibla och kan köra 32-bitars programvara direkt. Alla dina 32-bitars Windows-program kommer att köras precis som de skulle på en 32-bitarsversion av Windows. Det finns alltså inget hinder för att köra dessa program på ett 64-bitars operativsystem. Även om varje program du använder fortfarande är 32-bitars, kommer du att gynnas eftersom ditt operativsystem i sig kommer att köras i 64-bitarsläge. Och 64-bitarsversionen av Windows är säkrare.

64-bitarsprogram och 32-bitarsprogram: vilket är bättre?

32-bitarsprogram körs utan problem på 64-bitarsversioner av Windows operativsystem. Men skulle det vara bättre om alla dina program var 64-bitars? Det finns definitivt fördelar med 64-bitars program. 32-bitarsprogram kan bara använda 2 GB minne, medan 64-bitarsprogram kan använda mycket mer. Om ett program sannolikt kommer att utsättas för attack kan ytterligare säkerhetsfunktioner som tillämpas på 64-bitarsprogram hjälpa. Google Chrome är för närvarande en 32-bitarsapplikation även på 64-bitarsversioner av Windows OS, men en 64-bitars betaversion av detta program har redan dykt upp. Och Google lovar att 64-bitarsversionen av Chrome kommer att bli snabbare, säkrare och mer stabil. Vissa program erbjuder 64-bitarsversioner. Till exempel: Photoshop, iTunes, Microsoft Office och några av de mest populära Windows-programmen, och de är alla tillgängliga i 64-bitars form. Senaste spelen är också ofta 64-bitars så de kan använda mer än 2 GB minne. Många program har inte gjort övergången till 64-bitars, och de flesta kommer aldrig att göra det. Du kan fortfarande köra de flesta 32-bitars Windows-program idag, även de som släpptes för tio år sedan, på en 64-bitarsversion av Windows, även om deras utvecklare redan har uppdaterat dem. En utvecklare som vill tillhandahålla en 64-bitarsversion av sitt program måste göra mycket extraarbete. Han måste se till att den befintliga koden kompileras och körs korrekt som 64-bitars programvara. Det måste tillhandahålla och stödja två separata versioner av programmet, eftersom användare som kör en 32-bitarsversion av Windows inte kan använda 64-bitarsversionen. Låt oss ta Evernote för Windows-skrivbordet som ett exempel. Även om de släppte en 64-bitarsversion av Evernote, skulle användare förmodligen inte märka skillnaden alls. Ett 32-bitarsprogram kan köras alldeles utmärkt på en 64-bitarsversion av Windows, och om det inte finns några märkbara fördelar så är det ingen idé att ha en 64-bitarsversion.

Var du hittar 64-bitarsapplikationer

Du kommer vanligtvis inte att kunna välja mellan 32-bitars och 64-bitarsversioner av programvaran. Till exempel, när du installerar iTunes för Windows, leder Apples webbplats dig automatiskt till antingen 32-bitars eller 64-bitarsversionen av installationsprogrammet, beroende på din version av Windows. När du installerar Photoshop för Windows installeras vanligtvis både 32-bitars och 64-bitars körbara filer. Photoshop väljer automatiskt från dem. Ibland kan du se separata nedladdningslänkar för 32-bitars och 64-bitarsversioner av program, men det är inte så vanligt. Det viktiga är att inte söka efter 64-bitars applikationer, utan att hitta applikationer som fungerar bra för dig. För de flesta applikationer spelar det ingen roll om versionen är 64-bitars eller 32-bitars.

Det är lätt att undra varför så många applikationer fortfarande är 32-bitars när du öppnar din aktivitetshanterare. Men detta är inte ett särskilt stort problem och här är varför. Eftersom de flesta applikationer inte vinner något när man byter till 64-bitarsversioner av program. Även om utvecklarna gjorde allt arbete och släppte 64-bitarsversioner av alla små skrivbordsprogram och verktyg du använder på Windows, skulle du inte kunna se skillnad för de flesta av dem.

itchief.ru

7 steg för att överföra ett program till ett 64-bitarssystem

Artikeln diskuterar de viktigaste stegen för att säkerställa korrekt överföring av 32-bitars Windows-program till 64-bitars Windows-system. Även om artikeln riktar sig till utvecklare som använder språket C/C++ i Visual Studio 2005/2008, kommer den också att vara användbar för andra utvecklare som planerar att porta sina applikationer till 64-bitarssystem. Artikeln beskriver huvudpunkterna för utvecklare som planerar att migrera 32-bitarsprogram till 64-bitarssystem. Naturligtvis är listan över övervägda frågor inte komplett, men jag skulle vilja hoppas att en utökad version av denna artikel med tiden kommer att erbjudas. Författaren kommer att vara tacksam för feedback, kommentarer och frågor som kommer att förbättra informationsinnehållet i denna artikel. I datorarkitektur hänvisar termen "64-bitars" till 64-bitars heltal och andra datatyper som är 64 bitar stora. "64-bitars" system kan betyda 64-bitars mikroprocessorarkitekturer (till exempel EM64T, IA-64) eller 64-bitars operativsystem (till exempel Windows XP Professional x64 Edition). AMD64 (alias x86-64, Intel 64, EM64T, x64) är en 64-bitars mikroprocessorarkitektur och motsvarande instruktionsuppsättning utvecklad av AMD. Denna instruktionsuppsättning licensierades av Intel under namnet EM64T (Intel64). AMD64-arkitekturen är en förlängning av x86-arkitekturen med full bakåtkompatibilitet. Arkitekturen har blivit utbredd som bas för persondatorer och arbetsstationer. IA-64 är en 64-bitars mikroprocessorarkitektur utvecklad gemensamt av Intel och Hewlett Packard. Implementerad i Itanium och Itanium 2 mikroprocessorer. Arkitekturen används främst i multiprocessorservrar och klustersystem. AMD64 och IA-64 är två olika 64-bitars arkitekturer som inte är kompatibla med varandra. Därför bör utvecklare omedelbart bestämma om de behöver stödja båda dessa arkitekturer eller bara en. I de flesta fall, om du inte utvecklar högspecialiserad programvara för klustersystem eller implementerar ditt eget högpresterande DBMS, behöver du troligen bara implementera stöd för AMD64-arkitekturen, som är mycket mer utbredd än IA-64. Detta gäller särskilt för mjukvara för persondatormarknaden, som nästan 100 procent upptas av AMD64-arkitekturen. Vidare i artikeln kommer vi bara att prata om AMD64-arkitekturen (EM64T, x64), eftersom dess användning nu är mest relevant för programvaruutvecklare.

På tal om olika arkitekturer bör vi nämna konceptet "Data Model". En datamodell ska förstås som ett samband mellan dimensionerna av typer som accepteras inom utvecklingsmiljön. För ett operativsystem kan det finnas flera utvecklingsverktyg som följer olika datamodeller. Men vanligtvis är det bara en modell som råder, den som bäst matchar hård- och mjukvarumiljön. Ett exempel är 64-bitars Windows-operativsystemet, där den ursprungliga datamodellen är LLP64. Men för kompatibilitet stöder 64-bitars Windows-systemet körning av 32-bitarsprogram som körs i ILP32LL-datamodellläget. Tabell N1 ger information om de viktigaste datamodellerna.

Tabell N1. Datamodeller

Datamodellen som används påverkar utvecklingsprocessen för 64-bitars applikationer, eftersom programkoden måste ta hänsyn till bitdjupet för den data som används.

Du bör börja bemästra 64-bitars system med frågan "Behöver vi bygga om vårt projekt för ett 64-bitarssystem?" Denna fråga måste besvaras, men inte bråttom, efter att ha tänkt. Å ena sidan kan du hamna efter dina konkurrenter genom att inte erbjuda 64-bitarslösningar i tid. Å andra sidan kan du slösa bort din tid på en 64-bitarsapplikation som inte ger några konkurrensfördelar. Vi listar de viktigaste faktorerna som hjälper dig att göra ett val. Du bör inte skapa en 64-bitarsversion av ett program med en kort livscykel. Tack vare WOW64-undersystemet fungerar gamla 32-bitarsapplikationer ganska bra på 64-bitars Windows-system och därför är det ingen mening att göra ett 64-bitarsprogram som inte längre kommer att stödjas om 2 år. Dessutom har praxis visat att övergången till 64-bitarsversioner av Windows har försenats och kanske kommer majoriteten av dina användare på kort sikt bara att använda 32-bitarsversionen av din mjukvarulösning. Om du planerar för långsiktig utveckling och långsiktig support av en mjukvaruprodukt bör du börja arbeta med 64-bitarsversionen av din lösning. Detta kan göras långsamt, men tänk på att ju längre du inte har en fullfjädrad 64-bitarsversion, desto fler svårigheter kan uppstå med att stödja en sådan applikation installerad på 64-bitarsversioner av Windows. Om du kompilerar om programmet för ett 64-bitarssystem kan det använda enorma mängder RAM och kommer också att påskynda dess drift med 5-15%. En hastighetsökning på 5-10 % kommer att inträffa på grund av användningen av arkitektoniska kapaciteter hos en 64-bitars processor, till exempel ett större antal register. Ytterligare 1%-5% ökning i hastighet beror på frånvaron av WOW64-lagret, som översätter API-anrop mellan 32-bitars applikationer och 64-bitars operativsystem. Om ditt program inte fungerar med stora mängder data (mer än 2 GB) och dess hastighet inte är kritisk, är det inte så relevant att byta till ett 64-bitarssystem inom en snar framtid. Förresten, även enkla 32-bitars applikationer kan dra nytta av att köra dem i en 64-bitars miljö. Du vet förmodligen att ett program kompilerat med /LARGEADDRESSAWARE:YES-nyckeln kan allokera upp till 3 gigabyte minne om 32-bitars Windows-operativsystemet startas med /3gb-nyckeln. Samma 32-bitarsprogram som körs på ett 64-bitarssystem kan allokera nästan 4 GB minne (i praktiken cirka 3,5 GB). Om du utvecklar bibliotek, komponenter eller andra element som tredjepartsutvecklare använder för att skapa sin programvara, måste du vara proaktiv i att skapa en 64-bitarsversion av din produkt. Annars kommer dina kunder som är intresserade av att släppa 64-bitarsversioner att tvingas leta efter alternativa lösningar. Till exempel svarade vissa utvecklare av mjukvaru- och hårdvaruskydd med en lång fördröjning på uppkomsten av 64-bitarsprogram, vilket tvingade ett antal klienter att leta efter andra verktyg för att skydda sina program. En ytterligare fördel med att släppa en 64-bitarsversion av biblioteket är att du kan sälja det som en separat produkt. Således kommer dina kunder som vill skapa både 32-bitars och 64-bitars applikationer att tvingas köpa 2 olika licenser. Till exempel används denna policy av Spatial Corporation vid försäljning av Spatial ACIS-biblioteket. Innan du planerar att skapa 64-bitarsversioner av din produkt, ta reda på om det finns 64-bitarsversioner av biblioteken och komponenterna som den använder. Ta också reda på vad prispolicyn är för 64-bitarsversionen av biblioteket. Allt detta kan du ta reda på genom att besöka biblioteksutvecklarens webbplats. Om stöd inte är tillgängligt, leta i förväg efter alternativa lösningar som stöder 64-bitarssystem. Om dina lösningar fortfarande innehåller 16-bitarsmoduler är det dags att bli av med dem. Att köra 16-bitars applikationer på 64-bitarsversioner av Windows stöds inte. Här bör vi förtydliga en punkt relaterad till användningen av 16-bitars installatörer. De används fortfarande för att installera vissa 32-bitarsapplikationer. En speciell mekanism har skapats som i farten ersätter ett antal av de mest populära 16-bitarsinstallatörerna med nyare versioner. Detta kan orsaka missuppfattningen att 16-bitarsprogram fortfarande körs i en 64-bitarsmiljö. Kom ihåg att detta inte är sant. Glöm inte att användning av en stor mängd monteringskod avsevärt kan öka kostnaderna för att skapa en 64-bitarsversion av applikationen. Efter att ha vägt alla listade fakta, alla för- och nackdelar, bestäm dig för om du ska portera ditt projekt till 64-bitarssystem. Och om så är fallet, låt oss gå vidare. Bara för att du har bestämt dig för att utveckla en 64-bitarsversion av din produkt och är villig att lägga tid på det garanterar inte framgång. Faktum är att du måste ha alla nödvändiga verktyg och det kan uppstå obehagliga incidenter här.

Det enklaste, men också det mest oöverstigliga, problemet kan vara avsaknaden av en 64-bitars kompilator. Artikeln är skriven 2009, men det finns fortfarande ingen 64-bitars C++ Builder-kompilator från Codegear. Dess släpps väntas först i slutet av detta år. Det är omöjligt att komma runt ett liknande problem, om du naturligtvis inte skriver om hela projektet, till exempel med Visual Studio. Men om allt är klart med avsaknaden av en 64-bitars kompilator, kan andra liknande problem visa sig vara mer dolda och dyka upp redan i arbetet med att överföra projektet till en ny arkitektur. Därför skulle jag vilja råda dig att göra forskning i förväg för att avgöra om alla nödvändiga komponenter finns som kommer att krävas för att implementera 64-bitarsversionen av din produkt. Obehagliga överraskningar kan vänta dig.

Naturligtvis är det omöjligt att lista allt som kan behövas för ett projekt här, men jag kommer ändå att erbjuda en lista som hjälper dig att komma ihåg och kanske komma ihåg andra punkter som är nödvändiga för implementeringen av ditt 64-bitars projekt: Det är svårt att säga något annat om vikten av att ha en 64-bitars kompilator. Det måste bara vara. Om du planerar att utveckla 64-bitarsapplikationer med den senaste versionen (i skrivande stund) av Visual Studio 2008, kommer följande tabell N2 att hjälpa dig att avgöra vilken utgåva av Visual Studio du behöver.

Tabell N2. Funktioner hos olika utgåvor av Visual Studio 2008 Du kan naturligtvis använda virtuella maskiner för att köra 64-bitars applikationer på 32-bitars hårdvara, men detta är extremt obekvämt och ger inte den testnivå som krävs. Det är tillrådligt att maskiner har minst 4-8 gigabyte RAM installerat. Om bibliotek tillhandahålls i källkod måste en 64-bitars projektkonfiguration finnas. Att själv uppgradera ett bibliotek för att bygga det för ett 64-bitarssystem kan vara en otacksam och svår uppgift, och resultatet kan bli opålitligt och felbenäget. Du kan också bryta mot licensavtal genom att göra det. Om du använder bibliotek som binära moduler, bör du också ta reda på om det finns 64-bitars moduler. Du kommer inte att kunna använda 32-bitars DLL-filer i en 64-bitars applikation. Du kan skapa en speciell sele via COM, men detta kommer att vara en separat stor, komplex uppgift. Observera också att det kan kosta extra pengar att köpa 64-bitarsversionen av biblioteket. Visual C++ stöder inte 64-bitars inline assembler. Du måste använda antingen en extern 64-bitars assembler (till exempel MASM) eller ha en C/C++-implementering av samma funktionalitet. Betydande revidering av testmetodik, modernisering av enhetstester, användning av nya verktyg. Detta kommer att diskuteras mer i detalj nedan, men glöm inte att ta hänsyn till detta när du uppskattar den tid som går åt till att migrera en applikation till ett nytt system. Om du utvecklar resurskrävande applikationer som förbrukar en stor mängd RAM, måste du ta hand om att fylla på databasen med testindata. Vid belastningstestning av 64-bitars applikationer är det lämpligt att gå längre än 4 gigabyte minnesförbrukning. Många fel kan bara uppstå under sådana förhållanden. Skyddssystemet som används måste stödja 64-bitarssystem i den utsträckning du behöver. Till exempel släppte Aladdin snabbt 64-bitars drivrutiner för att stödja Hasp hårdvara nycklar. Men under mycket lång tid fanns det inget system för automatiskt skydd av 64-bitars binära filer (Hasp Envelop-programmet). Således var skyddsmekanismen tvungen att implementeras oberoende inom programkoden, vilket var en ytterligare komplex uppgift som krävde kvalifikationer och tid. Glöm inte liknande problem relaterade till säkerhet, uppdateringssystemet och så vidare. Du behöver ett nytt installationsprogram som fullt ut kan installera 64-bitarsapplikationer. Jag vill omedelbart varna dig för ett traditionellt misstag. Detta är skapandet av 64-bitars installationsprogram för att installera 32/64-bitars mjukvaruprodukter. När man förbereder en 64-bitarsversion av en applikation vill utvecklare ofta göra den helt 64-bitars. Och de skapar ett 64-bitars installationsprogram och glömmer att användare av ett 32-bitars operativsystem helt enkelt inte kommer att köra ett sådant installationspaket. Observera att det inte är 32-bitarsprogrammet som ingår i distributionen tillsammans med 64-bitarsprogrammet som inte startar, utan själva installationsprogrammet. När allt kommer omkring, om distributionen är en 64-bitars applikation, så kommer den naturligtvis inte att köras på ett 32-bitars operativsystem. Det mest irriterande med detta är att användaren inte kommer att kunna gissa vad som händer. Han kommer helt enkelt att se ett installationspaket som inte kan startas. Att skapa en 64-bitars projektkonfiguration i Visual Studio 2005/2008 ser ganska enkelt ut. Svårigheter kommer att vänta på dig när du sätter ihop en ny konfiguration och söker efter fel i den. För att skapa en 64-bitars konfiguration, fullfölj bara följande 4 steg: Starta konfigurationshanteraren, som visas i figur N1:

Figur 1. Starta konfigurationshanteraren Välj stöd för den nya plattformen i konfigurationshanteraren (Figur N2): Figur 2. Skapa en ny konfiguration Välj 64-bitarsplattformen (x64) och välj inställningarna från 32-bitarsversionen som grund (Figur N3). Visual Studio-miljön kommer att justera inställningarna som påverkar själva byggläget.

Figur 3. Välj x64 som plattform och använd Win32-konfigurationen som grund. Lägga till en ny konfiguration är klar, och vi kan välja 64-bitars konfigurationsalternativet och börja kompilera 64-bitarsapplikationen. Valet av 64-bitars konfiguration för montering visas i figur N4. Figur 4. 32-bitars och 64-bitars konfigurationer är nu tillgängliga. Om du har tur behöver du inte konfigurera ett 64-bitars projekt. Men detta beror mycket på projektet, dess komplexitet och antalet bibliotek som används. Det enda som behöver ändras direkt är stackstorleken. Om ditt projekt använder en standardstackstorlek, det vill säga 1 megabyte, är det vettigt att ställa in den på 2 megabyte för 64-bitarsversionen. Detta är inte nödvändigt, men det är bättre att vara på den säkra sidan i förväg. Om du använder en stackstorlek som skiljer sig från standardstorleken är det vettigt att göra den 2 gånger större för 64-bitarsversionen. För att göra detta, i projektinställningarna, hitta och ändra parametrarna Stack Reserve Size och Stack Commit Size. Här skulle det vara bra att prata om typiska problem som uppstår under kompileringsstadiet av en 64-bitars konfiguration. Fundera på vilka problem som uppstår med tredjepartsbibliotek, säg att kompilatorn i koden som är associerad med WInAPI-funktioner inte längre tillåter att placera en pekare i typen LONG och du måste modernisera din kod och använda typen LONG_PTG. Och många många andra. Tyvärr finns det så mycket av detta och felen är så varierande att det inte går att presentera det i en artikel eller ens kanske en bok. Du kommer att behöva titta igenom alla fel som kompilatorn kommer att producera och nya varningar som inte fanns där tidigare och i varje enskilt fall ta reda på hur man moderniserar koden.

En samling länkar till resurser dedikerade till utvecklingen av 64-bitarsapplikationer kan göra livet delvis enklare: http://www.viva64.com/links/64-bit-development/. Samlingen uppdateras ständigt och författaren kommer att vara tacksam mot läsarna om de skickar honom länkar till resurser som enligt deras mening förtjänar uppmärksamhet.

Vi kommer här endast att fokusera på de typer som kan vara av intresse för utvecklare vid migrering av applikationer. Dessa typer presenteras i tabell N3. De flesta kompileringsfel kommer att vara associerade med användningen av dessa typer.

Typ	Dimensionstyp på plattform x32 / x64	Notera
int	32 / 32	Grundläggande typ. På 64-bitars system förblir det 32-bitars.
lång	32 / 32	Grundläggande typ. På 64-bitars Windows-system förblir det 32-bitars. Observera att på 64-bitars Linux-system har denna typ utökats till 64-bitars. Glöm inte detta om du utvecklar kod som ska fungera och kompilera för Windows- och Linux-system.
storlek_t	32 / 64	Grundläggande osignerad typ. Storleken på typen är vald så att den kan rymma den maximala storleken på en teoretiskt möjlig array. En pekare kan säkert placeras i typen size_t (undantaget är pekare till klassfunktioner, men detta är ett specialfall).
ptrdiff_t	32 / 64	Liknar size_t-typen, men signerad. Resultatet av ett uttryck där en pekare subtraheras från en annan (ptr1-ptr2) kommer att vara av typen ptrdiff_t.
Pekare	32 / 64	Storleken på pekaren beror direkt på plattformens bitkapacitet. Var försiktig när du gjuter pekare till andra typer.
__int64	64 / 64	Signerad 64-bitars typ.
DWORD	32 / 32	32-bitars osignerad typ. Deklareras i WinDef.h som: typedef unsigned long DWORD;
DWORDLÅNG	64 / 64	64-bitars osignerad typ. Deklareras i WinNT.h som: typedef ULONGLONG DWORDLONG;
DWORD_PTR	32 / 64	En osignerad typ som kan hålla en pekare. Deklareras i BaseTsd.h som: typedef ULONG_PTR DWORD_PTR;
DWORD32	32 / 32	32-bitars osignerad typ. Deklareras i BaseTsd.h som: typedef unsigned int DWORD32;
DWORD64	64 / 64	64-bitars osignerad typ. Deklareras i BaseTsd.h som: typedef unsigned __int64 DWORD64;
HALF_PTR	16 / 32	En halv pekare. Deklareras i Basetd.h som:#ifdef _WIN64 typedef int HALF_PTR;#else typedef kort HALF_PTR;#endif
INT_PTR	32 / 64	En signerad typ i vilken en pekare kan placeras. Deklareras i BaseTsd.h som:#if defined(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR;#endif
LÅNG	32 / 32	En signerad typ som förblir 32-bitars. Därför bör LONG_PTR i många fall nu användas. Deklareras i WinNT.h som: typedef long LONG;
LONG_PTR	32 / 64	En signerad typ i vilken en pekare kan placeras. Deklareras i BaseTsd.h som:#if defined(_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR;#endif
LPARAM	32 / 64	Möjlighet att skicka meddelanden. Deklareras i WinNT.h som: typedef LONG_PTR LPARAM;
SIZE_T	32 / 64	Analogt med typen size_t. Deklareras i BaseTsd.h som: typedef ULONG_PTR SIZE_T;
SSIZE_T	32 / 64	Analogt med typen ptrdiff_t. Deklareras i BaseTsd.h som: typedef LONG_PTR SSIZE_T;
ULONG_PTR	32 / 64	En osignerad typ som kan hålla en pekare. Deklareras i BaseTsd.h som:#if defined(_WIN64) typedef unsigned __int64 ULONG_PTR;#else typedef unsigned long ULONG_PTR;#endif
ORD	16 / 16	Osignerad 16-bitars typ. Deklareras i WinDef.h som: typedef unsigned short WORD;
WPARAM	32 / 64	Möjlighet att skicka meddelanden. Deklareras i WinDef.h som: typedef UINT_PTR WPARAM;

Tabell N3. Typer av intresse vid portering av 32-bitarsprogram till 64-bitars Windows-system. Om du tror att efter att ha rättat alla kompileringsfel kommer den efterlängtade 64-bitarsapplikationen att erhållas, måste du bli besviken. Det svåraste är ännu att komma. I kompileringsstadiet kommer du att korrigera de mest uppenbara felen som kompilatorn kunde upptäcka, vilka främst är relaterade till omöjligheten av implicit typgjutning. Men det här är toppen av isberget. De flesta av felen är dolda. Ur det abstrakta C++-språkets synvinkel ser dessa fel säkra ut eller är förklädda av explicita typavgjutningar. Det finns flera gånger fler sådana fel än antalet fel som identifierats vid sammanställningsstadiet.

Du bör inte sätta dina förhoppningar på /Wp64-nyckeln. Den här nyckeln framhålls ofta som ett mirakelverktyg för att hitta 64-bitarsfel. Faktum är att /Wp64-växeln bara gör det möjligt, när man kompilerar 32-bitars kod, att få några varningar om att vissa delar av koden kommer att vara felaktiga i 64-bitarsläge. Vid kompilering av 64-bitars kod kommer dessa varningar att utfärdas av kompilatorn i alla fall. Och därför ignoreras /Wp64-nyckeln när en 64-bitars applikation kompileras. Och ännu mer så hjälper den här nyckeln inte att hitta dolda fel.

Låt oss titta på några exempel på dolda fel. Den enklaste, men inte den lättaste att upptäcka, felklassen är associerad med gjutning av explicit typ, där betydande bitar skärs av. Ett vanligt exempel är att sända pekare till 32-bitarstyper när de skickas till funktioner som SendMessage:

MyObj* pObj = ... ::SendMessage(hwnd, msg, (WORD)x, (DWORD)pObj);

Här används en explicit typcast för att konvertera en pekare till en numerisk typ. För en 32-bitars arkitektur är exemplet ovan korrekt, eftersom den sista parametern i SendMessage-funktionen är av typen LPARAM, vilket är samma som DWORD på en 32-bitars arkitektur. För 64-bitars arkitektur är användningen av DWORD felaktig och bör ersättas med LPARAM. LPARAM-typen har en storlek på 32 eller 64 bitar, beroende på arkitekturen.

Det här är ett enkelt fall, men ofta ser typbesättningen mer sofistikerad ut och kan inte upptäckas med hjälp av kompilatorvarningar eller genom att söka igenom programtexten. Explicita typcasts undertrycker kompilatordiagnostik eftersom de är avsedda att tala om för kompilatorn att typcasten är korrekt och programmeraren har accepterat ansvaret för kodens säkerhet. En explicit sökning hjälper inte heller. Typer kanske inte har standardnamn (specificerade av programmeraren via typedef), och det finns också en hel del sätt att implementera explicit typcasting. För att på ett tillförlitligt sätt diagnostisera sådana fel behöver du bara använda specialverktyg, som Viva64 eller PC-Lint-analysatorer.

Nästa exempel är relaterat till en implicit typcast, vilket också resulterar i förlust av betydande bitar. Fread-funktionskoden läser från en fil, men är felaktig när man försöker läsa mer än 2 gigabyte data på ett 64-bitarssystem.

size_t __fread(void * __restrict buf, size_t size, size_t count, FILE * __restrict fp); size_t fread(void * __restrict buf, size_t size, size_t count, FILE * __restrict fp) ( int ret; FLOCKFILE(fp); ret = __fread(buf, storlek, count, fp); FUNLOCKFILE(fp); return (ret) ;)

Funktionen __fread returnerar en size_t-typ, men int-typen används för att lagra antalet lästa byte. Som ett resultat, med stora mängder data som läses, kan funktionen returnera ett annat antal byte än vad som faktiskt kommer att läsas. Man kan säga att detta är okunnig kod för nybörjare, att kompilatorn kommer att rapportera en sådan typcast, och att sådan kod i allmänhet är lätt att hitta och korrigera. Detta är teoretiskt. Men i verkligheten, med stora projekt, kan allt vara annorlunda. Detta exempel är hämtat från FreeBSD-källkoden. Felet korrigerades först i december 2008! Detta trots att den första (experimentella) 64-bitarsversionen av FreeBSD släpptes redan i juni 2003. Här är källkoden före korrigeringen:

http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/fread.c?rev=1.14

Och här är den korrigerade versionen (december 2008):

http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/fread.c?rev=1.15

Det är lätt att göra fel i kod som fungerar med enskilda bitar. Nästa typ av fel är associerad med skiftoperationer. Låt oss titta på ett exempel:

ptrdiff_t SetBitN(ptrdiff_t värde, unsigned bitNum) ( ptrdiff_t mask = 1

Ovanstående kod fungerar på en 32-bitars arkitektur och låter dig ställa in bitar numrerade 0 till 31 till en. Efter att ha överfört programmet till en 64-bitars plattform kommer det att finnas ett behov av att ställa in bitar från 0 till 63. Men denna kod kommer aldrig att ställa in bitar numrerade 32-63. Observera att "1" är av typen int och när den skiftas med 32 positioner kommer ett spill att inträffa, som visas i figur 5. Huruvida resultatet är 0 (Figur 5-B) eller 1 (Figur 5-C) beror på kompilatorn genomförande.

Figur 5. A - Korrekt installation av den 31:a biten i en 32-bitars kod; B,C - Fel vid inställning av 32:a biten på ett 64-bitarssystem (två beteendealternativ) För att korrigera koden måste du göra en konstant "1" av samma typ som maskvariabeln:

ptrdiff_t mask = ptrdiff_t(1)

Observera också att okorrigerad kod kommer att leda till ytterligare en intressant bugg. När du ställer in 31 bitar på ett 64-bitarssystem blir resultatet av funktionen värdet 0xffffffff80000000 (se figur 6). Resultatet av uttryck 1 size_t ArraySize = N * 4; size_t *Array = (size_t *)malloc(ArraySize); De viktigaste siffrorna som bör tas med försiktighet vid byte till en 64-bitars plattform anges i Tabell N4.

Tabell N4. De viktigaste magiska värdena som är farliga vid överföring av applikationer från en 32-bitars till en 64-bitars plattform I program som bearbetar stora mängder data kan fel associerade med indexering av stora arrayer uppstå eller eviga loopar uppstå. Följande exempel innehåller 2 fel samtidigt:

const size_t size = ...; char *array = ...; char *end = array + storlek; för (osignerad i = 0; i != storlek; ++i) ( const int one = 1; end[-i - one] = 0; )

Det första felet är att om storleken på den bearbetade datan överstiger 4 gigabyte (0xFFFFFFFF), så kan en evig loop uppstå, eftersom variabeln "i" är av typen "unsigned" och aldrig kommer att nå värdet 0xFFFFFFFF. Jag skriver specifikt att förekomsten är möjlig, men det kommer inte nödvändigtvis att hända. Det beror på vilken kod kompilatorn bygger. Till exempel, i felsökningsläge kommer den eviga slingan att vara närvarande, men i releasekoden kommer loopingen att försvinna, så kompilatorn kommer att bestämma sig för att optimera koden med ett 64-bitars register för räknaren och slingan blir korrekt. Allt detta ökar förvirringen och kod som fungerade igår kan plötsligt sluta fungera nästa dag. Det andra felet är associerat med att passera genom en array från slutet till början, för vilken negativa indexvärden används. Ovanstående kod fungerar i 32-bitarsläge, men när den körs på en 64-bitars maskin, vid den allra första iterationen av slingan, kommer arrayen att nås bortom gränserna och programmet kommer att krascha. Låt oss titta på orsaken till detta beteende. Enligt C++-språkregeln på ett 32-bitarssystem kommer uttrycket "-i - one" att utvärderas enligt följande (i det första steget i = 0):

1. Uttrycket "-i" är av typen unsigned och har värdet 0x00000000u.
2. Variabeln "one" kommer att utökas från typ "int" till typ unsigned och kommer att vara lika med 0x00000001u. Notera: Typen int utökas (enligt språkstandarden C++) till att skriva "unsigned" om den deltar i en operation där det andra argumentet är av typen unsigned.
3. En subtraktionsoperation inträffar, som involverar två värden av typen utan tecken, och resultatet av operationen är 0x00000000u - 0x00000001u = 0xFFFFFFFFu. Observera att resultatet är av osignerad typ.
4. På ett 32-bitarssystem är åtkomst till en array vid index 0xFFFFFFFFu likvärdigt med att använda index -1. Det vill säga slutet är analogt med slutet[-1]. Som ett resultat bearbetas arrayelementet korrekt.

I ett 64-bitarssystem i sista stycket blir bilden annorlunda. Den osignerade typen kommer att utökas till signerad ptrdiff_t och arrayindexet kommer att vara lika med 0x00000000FFFFFFFFi64. Som ett resultat kommer arrayen att vara utanför gränserna. För att fixa koden måste du använda typer som ptrdiff_t och size_t. Det finns misstag som i allmänhet ingen kan skyllas för, men det hindrar dem inte från att vara misstag. Föreställ dig att för länge sedan i en avlägsen galax (i Visual Studio 6.0) utvecklades ett projekt som innehöll klassen CSampleApp, som är en ättling till CWinApp. Basklassen har en virtuell funktion som heter WinHelp. Arvingen åsidosätter denna funktion och utför nödvändiga åtgärder. Detta visas visuellt i figur 7.

Figur 7. Fungerar korrekt kod som skapades i Visual Studio 6.0 Sedan överförs projektet till Visual Studio 2005, där prototypen för WinHelp-funktionen har ändrats, men ingen märker detta, eftersom i 32-bitarsläge typerna DWORD och DWORD_PTR är desamma och programmet fortsätter att fungera korrekt (Figur 8).

Figur 8. Felaktig men fungerande 32-bitars kod Felet väntar på att manifestera sig på ett 64-bitarssystem, där storleken på DWORD- och DWORD_PTR-typerna är olika (Figur 9). Det visar sig att i 64-bitarsläge innehåller klasserna två OLIKA WinHelp-funktioner, vilket naturligtvis är felaktigt. Observera att sådana fällor kan döljas inte bara i MFC, där vissa funktioner har ändrat typen av argument, utan också i koden för dina applikationer och tredjepartsbibliotek.

Figur 9. Felet visar sig i 64-bitars kod Exempel på liknande 64-bitars fel kan ges och ges. De som är intresserade av sådana fel och vill lära sig mer om dem kommer att vara intresserade av artikeln "20 fallgropar för att porta C++-kod till en 64-bitars plattform." Som du kan se är steget att hitta dolda fel en icke-trivial uppgift, särskilt eftersom många av dem kommer att dyka upp oregelbundet eller bara på stora indatavolymer. Statiska kodanalysatorer är väl lämpade för att diagnostisera sådana fel, eftersom de kan kontrollera hela applikationskoden, oavsett indata och frekvensen av exekvering av dess sektioner i verkliga förhållanden. Det är vettigt att använda statisk analys både i det skede av portering av en applikation till 64-bitars plattformar för att hitta de flesta fel i det allra första skedet, och i vidareutvecklingen av 64-bitars lösningar. Statisk analys kommer att varna och lära programmeraren att bättre förstå funktionerna i fel som är associerade med 64-bitars arkitektur och skriva mer effektiv kod. Författaren till artikeln är utvecklaren av en av dessa specialiserade kodanalysatorer, kallad Viva64. Du kan bekanta dig med verktyget mer i detalj och ladda ner en demoversion från webbplatsen för Software Verification Systems LLC-företaget. För att vara rättvis ska det sägas att kodanalysatorer som Gimpel PC-Lint och Parasoft C++Test har uppsättningar regler för att diagnostisera 64-bitars fel. Men för det första är dessa analysatorer för allmänna ändamål och reglerna för att diagnostisera 64-bitars fel är dåligt representerade i dem. För det andra är de mer fokuserade på LP64-datamodellen som används i Linux-operativsystemfamiljen, vilket minskar användbarheten för Windows-program som använder LLP64-datamodellen. Steget att hitta fel i programkoden som beskrivs i föregående avsnitt är ett nödvändigt men inte tillräckligt steg. Ingen metod, inklusive statisk kodanalys, ger en fullständig garanti för att upptäcka alla fel, och det bästa resultatet kan endast uppnås genom att kombinera olika tekniker.

Om ditt 64-bitarsprogram bearbetar mer data än 32-bitarsversionen måste du utöka testerna till att omfatta bearbetning av data större än 4 gigabyte. Detta är gränsen bortom vilken många 64-bitars fel börjar manifestera sig. Sådana tester kan ta en storleksordning längre och du måste vara beredd på detta i förväg. Typiskt är prov skrivna på ett sådant sätt att man bearbetar ett litet antal moment i varje test och därmed klarar alla interna enhetstester, till exempel? på några minuter, och automatiserade tester (till exempel med AutomatedQA TestComplete) på några timmar. En sorteringsfunktion på ett 32-bitarssystem, om den sorterar 100 element, är nästan garanterat att fungera korrekt på 100 000 element. Men samma funktion på ett 64-bitarssystem kan misslyckas när man försöker bearbeta 5 miljarder element. Exekveringshastigheten för ett enhetstest kan minska miljontals gånger. Glöm inte att räkna in kostnaden för att anpassa tester när du behärskar 64-bitars system. En lösning är att dela upp enhetstester i snabba (att arbeta med en liten mängd minne) och långsamma, bearbeta gigabyte och köra till exempel på natten. Automatiserad testning av resurskrävande 64-bitarsprogram kan byggas på basis av distribuerad beräkning.