\nLast time, we saw how\n\nthose extra bits can be used to multiplex \nAs I noted in the base article,\nthe people who are most interested in this sort of thing are people\nwriting low-level class libraries or wrapping kernel objects inside\na larger framework.\n<\/P>\n \nSuppose, for example, you are writing a library that manipulates\nkernel objects, but you also have private types of objects (say,\na handle to a remote computer)\nthat you also want this library to be able to manipulate.\nOne way of doing this is to wrap everything inside some base class\nthat virtualizes away what type of handle you’re working on:\n<\/P>\n class KernelExtendedHandle : public ExtendedHandle {\npublic:\n static KernelExtendedHandle *Create(…);\n ExtendedHandleType GetType() { return KernelHandle; }\n HANDLE GetHandle() { return Handle; }\nprivate:\n KernelExtendedHandle(…);\n HANDLE Handle;\n};<\/p>\n class RemoteComputerExtendedHandle : public ExtendedHandle {\npublic:\n static RemoteComputerExtendedHandle *Create(…);\n ExtendedHandleType GetType() { return RemoteComputer; }\n LPCTSTR GetComputerName() { … }\n … other remote computer methods …\nprivate:\n RemoteComputerExtendedHandle(…);\n … stuff necessary for tracking remote computers …\n};\n<\/PRE>\n \nNow, your library spends only 1% of its time manipulating these\nprivate object types;\nmost of the time, it’s dealing with regular kernel handles.\nIn other words,\n99% of your objects are of type \nBut you can do better if you have those extra bits to play with.\nSince 99% of the objects you’re wrapping are just plain old kernel\nhandles, you can say that\nif the bottom bit is clear, then it’s just a kernel handle,\nand if the bottom bit is set, then the upper bits tell us what\nwe are really operating on.\n<\/P>\n BOOL IsKernelHandle(EHANDLE Handle)\n{\n return (!((INT_PTR)Handle & 1));\n}<\/p>\n EHANDLE CreateHandleFromKernelHandle(HANDLE Handle)\n{\n \/\/ if this assertion fires, then somebody tried to\n \/\/ use an invalid kernel handle!\n assert((!((INT_PTR)Handle & 1));\n return (EHANDLE)Handle;\n}<\/p>\n EHANDLE CreateHandleFromExtendedHandle(ExtendedHandle Handle)\n{\n \/\/ if this assertion fires, then somebody allocated\n \/\/ a misaligned ExtendedHandle!\n assert(!((INT_PTR)Handle & 1));\n return (EHANDLE)((INT_PTR)Handle | 1));\n}<\/p>\n ExtendedHandle *GetExtendedHandle(EHANDLE Handle)\n{\n assert(!IsKernelHandle(Handle));\n return (ExtendedHandle*)((INT_PTR)Handle & ~1);\n}<\/p>\n ExtendedHandleType GetType(EHANDLE Handle)\n{\n if (IsKernelHandle(Handle)) {\n return KernelHandleType;\n } else {\n return GetExtendedHandle(Handle)->GetType();\n }\n}<\/p>\n void ECloseHandle(EHANDLE Handle)\n{\n if (IsKernelHandle(Handle))\n {\n CloseHandle(GetKernelHandle(Handle));\n } else {\n delete GetExtendedHandle(Handle);\n }\n}\n<\/PRE>\n \nNow the cost of a wrapped kernel handle is just 4 bytes:\n4 bytes for the \nIf you are not confident that your ExtendedHandle *GetExtendedHandle(EHANDLE Handle)\n{\n assert(!IsKernelHandle(Handle));\n return ExtendedHandleTable[(INT_PTR)Handle >> 1];\n}\n<\/PRE>\nHANDLE<\/CODE>\nwith other values<\/A>.\nThat was a specific case of a more general scenario:\nExpanding the handle namespace to include things that aren’t handles.\n(You can also view today’s example as a generalization of the\n\nsentinel value problem<\/A>,\nwhere we need to generate an arbitrary number of sentinel values dynamically.\nActually, multiplexing HANDLE<\/CODE> with HRESULT<\/CODE>\nis also just another special case: We expanded the handle namespace\nto include error codes too.)\n<\/P>\n\nclass ExtendedHandle {\npublic:\n virtual ExtendedHandleType GetType() = 0;\n virtual ~ExtendedHandle() { }\n};<\/p>\nKernelExtendedHandle<\/CODE>.\nWhat used to be just a HANDLE<\/CODE> (4 bytes)\nis now a EHANDLE<\/CODE> that in turn points to an 8-byte\nstructure\n(4 bytes for the vtable and\n4 bytes for the HANDLE<\/CODE>).\nYour memory requirements have tripled and<\/I> you added\nanother level of indirection (costing you locality),\njust for that 1% case.\n<\/P>\n\ntypedef void *EHANDLE;<\/p>\n
EHANDLE<\/CODE>, which also doubles\nas the actual kernel handle.\nThe cost of wrapped pseudo-handles is the same as before\n(4 bytes for the EHANDLE<\/CODE>, plus the size\nof the corresponding XxxExtendedHandle<\/CODE> class).\nWe used the trick from last time in order to pack 33 bits\ninto only 32 bits:\nSince we know that the bottom bit of both kernel HANDLE<\/CODE>s\nand ExtendedHandle<\/CODE> pointers are zero,\nwe can use it as a discriminator.\n<\/P>\nExtendedHandle<\/CODE>\nclasses all use aligned pointers, you can use a different packing\nmechanism by using your own handle translation table:\n<\/P>\n\nExtendedHandle *ExtendedHandleTable;<\/p>\n