int64.org

November 2007 Archives

AMD taking a page from Intel’s marketing

AMD’s new Phe­nom proces­sor comes with a new in­struc­tion set called SSE4a. For a while I’ve been run­ning under the as­sump­tion that this also meant they caught up and added sup­port for SSSE3, and that SSE4a was sim­ply SSE4 with a few new in­struc­tions added on. This was pretty cool to me, be­cause SSE4 has some nice in­struc­tions like DPPS that I was look­ing for­ward to using.

Turns out it’s not so – SSE4a doesn’t in­clude any of the 54 new in­struc­tions in SSE4. What it does add is 8 new in­struc­tions, one of which is sim­i­lar to but in­com­pat­i­ble with a SSE4 in­struc­tion. SSE4 aside, the Phe­nom still doesn’t even have sup­port for SSSE3.

Al­though they have im­proved quite a bit re­cently, Intel is well known for using anti–con­sumer tac­tics in mar­ket­ing in the past. The "GHz myth" they started will un­doubt­edly be fresh in the minds of weary techies for years to come. I never ex­pected AMD to sink to such un­der­handed mar­ket­ing, but it ap­pears they have: SSE4a is named to be noth­ing more than con­fus­ing to po­ten­tial con­sumers.

C++0x work progressing

A bit de­layed, but I just found the re­sults of the Oc­to­ber 2007 C++ meet­ing. In it, they voted in sev­eral re­ally nice things for the C++0x draft:

• nullptr – no more using 0 or NULL and get­ting int/pointer over­load is­sues. ( N2431)
• Atomic li­brary – comes with sev­eral classes and util­ity func­tions for work­ing with mem­ory or­der­ing and lock–free al­go­rithms. ( N2427)
• Thread­ing li­brary – basic thread­ing, mu­texes, and con­di­tion vari­ables. ( N2447)
• Uni­code lit­er­als – UTF-8 and UTF-16 string lit­er­als. ( N2442)
• Uni­code codecvt facets – UTF-8 and UTF-16 codecvt facets for read­ing Uni­code streams. ( N2401)

Using proper punctuation marks

I re­cently learned that the lov­able char­ac­ter be­tween the 0 and the = key on QW­ERTY key­boards is not a hy­phen (U+2010) nor a minus (U+2212), but a hy­phen–minus (U+002D). Not just that, but I learned of the ex­is­tence of var­i­ous dashes, such as the fig­ure dash (U+2012), en dash (U+2013), and em dash (U+2014).

Using proper punc­tu­a­tion marks can be es­pe­cially hard for the sim­ple fact that they don’t exist on my key­board. Mi­crosoft Word will au­to­mat­i­cally re­place two hy­phens with a dash, but what about the rest of the apps I use? For now, I’m stuck using the te­dious Alt+Numpad for­mula, or copy–past­ing from the Char­ac­ter Map. I think this auto–cor­rec­tion would be a great thing to in­te­grate into Win­dows, per­haps into an IME. Call it the next evo­lu­tion of input, like how speech recog­ni­tion was added to Vista.

Working with cryptography; turns out it’s not so simple

While com­ing up with a new list for­mat for Peer­Guardian 3, I de­cided it should have built in dig­i­tal sig­na­tures, so every­one get­ting lists can ver­ify the in­tegrity and who the list came from.

Al­though I’ve used crypto sys­tems like GPG be­fore and un­der­stood the ba­sics of it, I’d never im­ple­mented one my­self. So after much re­search, I de­cided on LibTom­Crypt due to its sim­ple API, stel­lar doc­u­men­ta­tion, and sup­port for mod­ern al­go­rithms like AES and ECC. Being en­tirely in the pub­lic do­main is a good perk, too.

The first it­er­a­tion is a very basic pub­lic key sys­tem. After fur­ther read­ing, I’ve de­cided it would be use­ful to im­ple­ment a full pub­lic key in­fra­struc­ture – that is, signed keys and pos­si­bil­ity of re­vo­ca­tion. This al­lows Phoenix Labs (or any­one else) to sign other pub­lic keys to ver­ify they’re legit and trust­wor­thy, and later re­voke the key if some­thing hap­pens with it (such as the pri­vate key being leaked).

All in all, it’s turn­ing out to be a lot more work than I ex­pected, but I don’t mind – it’s some­thing new and in­ter­est­ing, which seems to hap­pen less and less these days.

Visual Studio 2008 released, TR1 support coming

Any­one fol­low­ing Vi­sual Stu­dio 2008 will know that al­though it of­fers a plethora of new fea­tures for the man­aged world, there was lit­tle focus on the un­man­aged side of things. Now that it is fi­nally out the door, I guess it’s a good time to look at what few new fea­tures are there for us un­man­aged C++ coders.

• Im­proved stan­dards con­for­mance with sup­port for friend tem­plates, an un­com­mon but pow­er­ful C++ fea­ture.
• In­trin­sic sup­port for SSSE3, SSE4.x, and SSE4a. These are mod­ern vec­tor in­struc­tions (SSE4a lit­er­ally just came out with AMD’s Phe­nom proces­sors!) that any­one in­ter­ested in writ­ing high‐per­for­mance code will want to be fa­mil­iar with.
• In­trin­sic sup­port for the CM­PX­CHG16B in­struc­tion. This in­struc­tion is es­sen­tial when writ­ing many lock-free al­go­rithms for the x64 plat­form. I’ve been lob­by­ing to have it added for a long time, so I’m es­pe­cially happy to fi­nally see it. Un­for­tu­nately, the gen­er­ated code in Beta 2 was very sub‐op­ti­mal (con­sid­er­ing the in­struc­tion is typ­i­cally used in very tight loops) so I may end up using as­sem­bly any­way! I’m anx­ious to see if it is im­proved in RTM.
• Im­proved op­ti­mizer, with sup­port for in­lin­ing tran­scen­den­tal func­tions and sched­ul­ing for the lat­est CPUs.
• Linker op­tions up­dated for Vista – abil­ity to spec­ify UAC and ad­dress space ran­dom­iza­tion prop­er­ties. For some rea­son, still no sup­port for DPI in­de­pen­dence so we’ll end up writ­ing man­i­fests any­way.
• We can fi­nally use those quad‐core CPUs that are com­ing out to re­duce our com­pile times with Multi‐threaded com­pil­ing.

Not much, huh? That’s be­cause Mi­crosoft was run­ning under the as­sump­tion that peo­ple would flock to C# and only use un­man­aged C++ to main­tain "legacy" code. Per­haps the best news so far, they’ve fi­nally re­al­ized their mis­take. Al­though they didn’t have time to put things into VC++ 2008, they have re‐com­mit­ted to un­man­aged code for the next ver­sion and in the mean­time made a small sep­a­rate an­nounce­ment that they will be bring­ing VC++ 2008 users a mostly com­plete TR1 im­ple­men­ta­tion up­date in early Jan­u­ary.