![\"twitter\"](\"https:\/\/blog.capdata.fr\/wp-content\/plugins\/social-media-feather\/synved-social\/image\/social\/regular\/48x48\/twitter.png\" "\\"Share")
<\/a><\/a>![\"linkedin\"](\"https:\/\/blog.capdata.fr\/wp-content\/plugins\/social-media-feather\/synved-social\/image\/social\/regular\/48x48\/linkedin.png\" "\\"Share")
<\/a>![\"mail\"](\"https:\/\/blog.capdata.fr\/wp-content\/plugins\/social-media-feather\/synved-social\/image\/social\/regular\/48x48\/mail.png\" "\\"Share")
<\/a>Ce post est le premier d’une s\u00e9rie sur les API syst\u00e8mes impliqu\u00e9es au niveau de SQL Server:<\/p>\n
Cette s\u00e9rie plut\u00f4t barbare va d\u00e9vier un peu des sujets SGBD traditionnels. Elle s’adresse \u00e0 toute personne souhaitant approfondir les m\u00e9canismes intrins\u00e8ques de SQL Server, pour en comprendre la logique et les contraintes. Ces articles seront class\u00e9s sous les sujets Operating System<\/a> et SQL Server<\/a>. Leur lecture n\u00e9cessite que vous ayez des connaissances minimum sur C\/C++ et l’API win32.<\/p>\n Dans un post pr\u00e9c\u00e9dent<\/a>, nous avions d\u00e9j\u00e0 effleur\u00e9 la question de l’\u00e9criture \u00e0 travers le cache, nous reprendrons le m\u00eame exemple pour \u00e9voquer le sujet du jour: les I\/Os asynchrones dans des fichiers. C’est une question large donc je propose d’\u00e9clater le sujet en trois \u00e9pisodes:<\/p>\n Quand on \u00e9crit un programme sous windows, on doit t\u00f4t ou tard acc\u00e9der \u00e0 un device en lecture \/ \u00e9criture. La plupart des applications que l’on utilise n’ont pas besoin d’\u00e9crire tr\u00e8s souvent des\u00a0 donn\u00e9es durables. Souvent elles misent sur la bufferisation des entr\u00e9es \/ sorties, c’est \u00e0 dire l’\u00e9criture ou la lecture de donn\u00e9es en m\u00e9moire. Parfois cependant, elles devront lire des donn\u00e9es sur disque, par exemple lorsqu’elles d\u00e9marrent, ou bien \u00e9crire des informations dans un fichier de configuration lorsqu’elles s’arr\u00eatent. Le moyen de plus simple de lire ou d’\u00e9crire dans un fichier est alors de lancer une entr\u00e9e\/sortie synchrone <\/span>en utilisant ReadFile() ou WriteFile().<\/p>\n On utilise le terme synchrone parce que le thread qui a initi\u00e9 cette \u00e9criture ou cette lecture doit attendre l\u2019acquittement ou le retour de l’entr\u00e9e\/sortie avant de pouvoir continuer son ex\u00e9cution. D\u00e8s que la demande de lecture ou d’\u00e9criture est lanc\u00e9e, il entre imm\u00e9diatement dans un \u00e9tat d’attente, il ne peut rien faire d’autre. De la sorte, s’il doit lancer de nombreuses op\u00e9rations d’entr\u00e9es sorties, il va devoir attendre que chacune soit termin\u00e9e avant de pouvoir ex\u00e9cuter la suivante, ce qui va limiter en quelque sorte sa capacit\u00e9 \u00e0 traiter un grand nombre d’op\u00e9rations par seconde.<\/p>\n L’alternative est d’indiquer au thread de ne pas attendre le retour de l’I\/O pour continuer son ex\u00e9cution, en postant des I\/Os asynchrones <\/span>(ou overlapped IO). Il existe plusieurs contraintes associ\u00e9es \u00e0 l’utilisation des IO asynchrones, qui rendent la chose nettement plus compliqu\u00e9e \u00e0 g\u00e9rer:<\/p>\n Dans la pratique, chaque thread\u00a0 peut se synchroniser de 4 mani\u00e8res diff\u00e9rentes:<\/strong><\/p>\n Que l’on utilise des entr\u00e9es\/sorties synchrones ou asynchrones, les primitives utilis\u00e9es sont les m\u00eames [2], on leur passera simplement des param\u00e8tres diff\u00e9rents. Pour pouvoir pister nos entr\u00e9es \/ sorties asynchrones, on va utiliser un genre de traceur sous la forme d’une structure C appel\u00e9e\u00a0 Overlapped<\/strong><\/a>. Si on regarde sa composition de plus pr\u00e8s:<\/p>\n Parmi les propri\u00e9t\u00e9s importantes pour le code utilisateur, Offset <\/span>et OffsetHigh <\/span>d\u00e9limitent une portion de 64 bits de donn\u00e9es et indiquent \u00e0 quel endroit on va commencer d’\u00e9crire dans le fichier. Offset <\/span>g\u00e8re les 32 premiers bits pour les fichiers < 4Gb (souvenez-vous FAT 32…), et OffsetHigh <\/span>les 32 suivants pour les fichiers de plus de 4Gb. Si on ex\u00e9cutait deux IO synchrones, elles s’ex\u00e9cuteraient l’une derri\u00e8re l’autre et le kernel s’occupperait d’indiquer \u00e0 la seconde \u00e9criture o\u00f9 elle doit commencer, parce que la premi\u00e8re s’est termin\u00e9e et donc on sait o\u00f9 on en est. Mais dans le cas d’\u00e9critures asynchrones, on n’a pas cette information, donc si on ex\u00e9cute une seconde entr\u00e9e\/sortie avant que la premi\u00e8re ne soit termin\u00e9e, il faut pouvoir g\u00e9rer les offsets soi-m\u00eame. C’est le r\u00f4le de ces deux propri\u00e9t\u00e9s, mais c’est \u00e0 nous de les maintenir. Lors d’une premi\u00e8re ex\u00e9cution, ces deux valeurs doivent \u00eatre initalis\u00e9es (souvent \u00e0 0 pour marquer le premier offset en d\u00e9but de fichier):<\/p>\n De son c\u00f4t\u00e9, hEvent <\/span>est l’event\u00a0 que l’on va pouvoir utiliser pour synchroniser le thread sur l’I\/O asynchrone. Si on utilise cette technique, alors il va falloir l’initialiser avec CreateEvent() en lui passant un event \u00e0 reset manuel et dans l’\u00e9tat non – signal\u00e9 (second et troisi\u00e8me param\u00e8tres, cf MSDN CreateEvent()<\/a>)<\/p>\n Une structure OVERLAPPED est associ\u00e9e \u00e0 chaque I\/O asynchrone que l’on va effectuer. Si on en lance 8 en m\u00eame temps, il faudra cr\u00e9er et initialiser 8 structures. On peut utiliser un OVERLAPPED [] pour stocker toutes nos instances de structure par exemple. La chose la plus importante au sujet d’OVERLAPPED, est qu’elle doit toujours \u00eatre accessible pendant toute la dur\u00e9e de vie de l’I\/O, donc pas question d’allouer le tableau d’OVERLAPPED[] sur la stack. Le cas d’erreur le plus courant est d’ex\u00e9cuter un appel \u00e0 ReadFile() ou WriteFile() dans une fonction et g\u00e9rer la compl\u00e9tion dans le main ou une autre fonction, par exemple:<\/p>\n Lorsque la fonction sort la stack est vid\u00e9e alors que le driver pointe encore vers &ov<\/span> qui n’est d\u00e9j\u00e0 plus valide.<\/p>\n Pour indiquer \u00e0 Windows que l’on souhaite faire des I\/O asynchrones sur un fichier, on utilise un flag sp\u00e9cifique <\/strong>FILE_FLAG_OVERLAPPED<\/strong><\/span>, que l’on passe \u00e0 CreateFile(), tel que:<\/p>\n A noter que cet exemple utilise aussi des I\/Os non bufferis\u00e9es comme nous l’avons d\u00e9j\u00e0 vu dans l’article sur SATA<\/a>. SQL Server utilise pr\u00e9cis\u00e9ment tous ces flags pour ouvrir les fichiers MDF, NDF et LDF. Il ne reste plus qu’\u00e0 appeler ReadFile() ou WriteFile() en passant la structure Overlapped initialis\u00e9e:<\/p>\n Si on ex\u00e9cute au moins deux appels \u00e0 la suite \u00e0 ReadFile() ou WriteFile() , Windows ne sait pas o\u00f9 le premier en est et o\u00f9 le second peut commencer \u00e0 lire ou \u00e0 \u00e9crire. C’est donc au programme utilisateur de comptabiliser les offsets exacts o\u00f9 chaque IO va devoir s’appliquer. On utilise pour cela les deux propri\u00e9t\u00e9s Offset et OffsetHigh de la structure Overlapped.<\/p>\n Historiquement, le compilateur C qui supporte l’API win32 ne comporte pas de type natif sur 64 bits (ce n’est pas le cas du compilateur VC++). Donc on ne peut pas tracer des offsets d’une valeur sup\u00e9rieure \u00e0 4Gb. Et encore aujourd’hui, il faut jongler avec une construction de type LARGE_INTEGER<\/a> pour arriver \u00e0 jouer avec des offsets au del\u00e0 de 2e32:<\/p>\n En fait le type LARGE_INTEGER est une union d’un DWORD et d’un LONG pour former un LONGLONG de 64 bits. Si on consid\u00e8re le sch\u00e9ma ci-dessous:<\/p>\n On utilisera donc QuadPart pour allouer de nouvelles valeurs d’offsets sur 64 bits puis LowPart et HighPart pour les passer respectivement \u00e0 Offset et OffsetHigh, quelque chose comme :<\/p>\n Voici un exemple d’appel \u00e0 WriteFile() avec une structure overlapped tel que cod\u00e9 dans l’exemple:<\/p>\n D\u00e9j\u00e0 quelque chose doit vous interpeller \u00e0 ce niveau-l\u00e0 du code. Dans les faits, on n’a jamais la garantie \u00e0 100% d’obtenir du syst\u00e8me qu’il poursuive pour nous une IO asynchrone, car l’IO Manager a toujours le dernier mot. Il peut d\u00e9cider pour une raison ou pour une autre de transformer cette demande en IO synchrone. Donc il faut toujours tester le code retour de WriteFile() quand on lui passe une structure OVERLAPPED:<\/p>\n Utiliser des IO asynchrones, c’est un peu comme jongler avec plusieurs balles \u00e0 la fois: au bout d’un moment il va falloir les rattraper. Il faut donc choisir un point dans le code o\u00f9 on va devoir se synchroniser pour attendre le retour de ces IO avant de pouvoir continuer. On peut utiliser les primitives standard de synchronisation telles que WaitForSingleObject()<\/a>, et dans notre cas puisqu’on attend le retour de plusieurs IO, WaitForMultipleObjects()<\/a>.On bloque en passant \u00e0 la primitive le ou les events qui attendent d’\u00eatre signal\u00e9s:<\/p>\n Lorsqu’un premier event est signal\u00e9 parce que son IO vient de se terminer, WaitForMultipleObjects() retourne WAIT_OBJECT_0, et le code peut se poursuivre. WAIT_OBJECT_0 repr\u00e9sente le premier event qui vient d’\u00eatre signal\u00e9, on va s’en servir pour d\u00e9terminer l’indice de cet event dans un tableau, comme dans notre exemple comment\u00e9 ci-dessous. On va ensuite devoir r\u00e9cup\u00e9rer le nombre d’octets \u00e9crits, et si l’on souhaite r\u00e9utiliser la structure Overlapped, r\u00e9initialiser son event, puis rebloquer en attendant le retour d’une autre IO:<\/p>\n Il existe plusieurs primitives win32 pour g\u00e9rer la fin d’une IO asynchrone:<\/p>\n Il est important de n’ex\u00e9cuter GetOverlappedResults() que si l’IO est bien asynchrone, c’est pourquoi on teste avec un bool\u00e9en d’abord.<\/p>\n Voil\u00e0, on a fait le tour, place \u00e0 l’exemple comment\u00e9 !<\/p>\n Cet exemple reprend le principe de ce qui avait \u00e9t\u00e9 utilis\u00e9 dans l’article sur SATA<\/a>. Il utilise simplement des \u00e9critures asynchrones en plus. \u00c9videmment \u00e7a n’a pas grand int\u00e9r\u00eat de faire des \u00e9critures asynchrones dans ce contexte l\u00e0 (mono-thread, on lance un nombre d’IO puis on bloque sur la completion de l’ensemble), mais il a l’avantage d’\u00eatre simple et de ne pas nous embarquer dans des notions hors cadre de synchronisation de threads et compagnie… Encore une fois, il s’agit juste de comprendre le principe de mise en place.<\/p>\n On d\u00e9finit une quantit\u00e9 de donn\u00e9es \u00e0 \u00e9crire dans un fichier (FileSizeInBytes, par d\u00e9faut 10Mb) ainsi qu’un certain nombre d’outstanding IOs (MAXOUTSTANDINGIO), c’est \u00e0 dire d’IO simultan\u00e9es. On ne peut envoyer plusieurs IO simultan\u00e9es que si on effectue des IO asynchrones, c’est pourquoi on dit que des compteurs tels que ‘Current Disk Queue Length’ par exemple peuvent \u00eatre normalement \u00e9lev\u00e9s avec SQL Server, car on envoie plusieurs IOs en m\u00eame temps.<\/p>\n La prochaine fois, on verra comment faire pour utiliser les IO completion ports pour g\u00e9rer les IO asynchrones.<\/p>\n A+. David B.<\/p>\n Windows via C++<\/a> (Jeffrey Richter \/ Christope Navarre) [1] Dave Cutler, le papa de VMS et du premier kernel windows NT avait \u00e9t\u00e9 tellement d\u00e9prim\u00e9 par l’impl\u00e9mentation des APC dans VMS qu’il aurait d\u00e9clar\u00e9 plus tard lorsqu’il travaillait sur le kernel NT : “Asynchronous callback I\/O will go into Windows over my dead body!<\/span><\/span><\/span><\/span>“ Ce post est le premier d’une s\u00e9rie sur les API syst\u00e8mes impliqu\u00e9es au niveau de SQL Server: Gestion des entr\u00e9es\/sorties: alignement, I\/Os asynchrones, alternate streams, scatter gather, I\/O completion ports, etc… Le multithreading:\u00a0 synchronisation, events, mutexes, spinlocks, sections critiques… La… Continuer la lecture \n
SYNCHRONE vs ASYNCHRONE:<\/h2>\n
\n
\n
Principes d’utilisation dans le code:<\/h2>\n
La structure OVERLAPPED<\/h3>\n
typedef struct _OVERLAPPED {\r\n ULONG_PTR Internal;\r\n ULONG_PTR InternalHigh;\r\n union {\r\n struct {\r\n DWORD Offset;\r\n DWORD OffsetHigh;\r\n };\r\n PVOID Pointer;\r\n };\r\n HANDLE hEvent;\r\n} OVERLAPPED, *LPOVERLAPPED;<\/pre>\nOVERLAPPED ov; \r\nov.Offset = 0; \r\nov.OffsetHigh = 0;<\/pre>\n
VOID ReadMyFile(HANDLE h)\r\n{\r\n OVERLAPPED ov;\r\n BYTE b[255];\r\n ov.Offset=0;\r\n ov.OffsetHigh=0;\r\n ReadFile(h,b,255,NULL,&ov);\r\n}<\/pre>\n\/\/ Ouverture du fichier Writethrough + No Buffering + Overlapped ----------------------------\r\nHANDLE hOutputFile=CreateFile(argv[1]\r\n ,GENERIC_READ\r\n | GENERIC_WRITE\r\n ,0\r\n ,NULL\r\n ,CREATE_ALWAYS\r\n ,FILE_ATTRIBUTE_NORMAL\r\n | FILE_FLAG_WRITE_THROUGH\r\n | FILE_FLAG_NO_BUFFERING\r\n | FILE_FLAG_OVERLAPPED\r\n ,NULL);\r\n\r\n if (INVALID_HANDLE_VALUE==hOutputFile)\r\n {\r\n printf(\"Unable to open file %s. Last error=%d\\n\",argv[1],GetLastError());\r\n return 1;\r\n }<\/pre>\nWriteFile(hOutput,csBuffer,dg.BytesPerSector,&dwBytesWritten,&ov)<\/pre>\n
Gestion de Offset et OffsetHigh<\/h2>\n
typedef union LARGE_INTEGER {\r\n struct {\r\n DWORD LowPart;\r\n LONG HighPart;\r\n };\r\n LONGLONG QuadPart;\r\n};<\/pre>\n![\"\"](\"http:\/\/blog.capdata.fr\/wp-content\/uploads\/2011\/07\/large_integer.jpg\" "\\"large_integer\\"")
<\/a><\/p>\nOffsethOutput.QuadPart=0;\r\nwhile(!EOF)\r\n{\r\n ov.Offset = OffsethOutput.LowPart;\r\n ov.OffsetHigh = OffsethOutput.HighPart;\r\n BOOL b = Readfile (..., &ov);\r\n OffsethOutput.QuadPart += (LONGLONG) dg.BytesPerSector;\r\n}<\/pre>\nG\u00e9rer le retour de ReadFile() \/ WriteFile():<\/h3>\n
if (!WriteFile(hOutput,csBuffer,dg.BytesPerSector,&dwBytesWritten,&ov))\r\n{\r\n DWORD dwLastErr=GetLastError(); \r\n if (ERROR_IO_PENDING == dwLastErr)\r\n { \r\n isASYNCWRITE=TRUE; \/\/ On a une IO asynchrone\r\n OffsethOutput.QuadPart += (LONGLONG) dg.BytesPerSector; \/\/ On d\u00e9cale Offset et OffsetHigh de la valeur de l'IO\r\n } \r\n else\r\n {\r\n if (ERROR_SUCCESS == dwLastErr) \/\/ C'est une IO synchrone\r\n isASYNCWRITE=FALSE;\r\n else\r\n {\r\n printf(\"Error when Writing to file %S. Last error=%d\\n\",argv[1],GetLastError());\r\n return -1;\r\n }\r\n }\r\n}<\/pre>\n\n
R\u00e9cup\u00e9rer le r\u00e9sultat de l’IO une fois termin\u00e9e avec GetOverlappedResult()<\/h3>\n
dwEventSignPos = WaitForMultipleObjects(MAXOUTSTANDINGIO, hEvents, FALSE, INFINITE) - WAIT_OBJECT_0;<\/pre>\n
ResetEvent (hEvents[dwEventSignPos]);<\/pre>\n
\n
if (isASYNCWRITE)\r\n{\r\n if (!GetOverlappedResult(hOutput,&olwrite[dwEventSignPos],&dwBytesWritten[dwEventSignPos],TRUE))\r\n {\r\n printf(\"Error getting pending write IO. Last error=%d\\n\",GetLastError());\r\n break;\r\n }\r\n else\r\n {\r\n \/\/ Action principale: on totalise chaque fin d'\u00e9criture async\r\n llTotalBytesWritten+=dwBytesWritten[dwEventSignPos];\r\n }\r\n}<\/pre>\nExemple comment\u00e9 d’utilisation des I\/Os asynchrones:<\/h2>\n
\/\/ writethrougasync.cpp : Defines the entry point for the console application.\r\n\/\/\r\n#include \"stdafx.h\"\r\n#include\r\n#include\r\n#include\r\n#include\r\n\r\n#define MAXOUTSTANDINGIO 4 \/\/ Definit le nb d'IO max en cours\r\n#define FileSizeInBytes 10485760 \/\/ Definit la taille max du fichier\r\n\r\nint _tmain(int argc, _TCHAR* argv[])\r\n{\r\n if (argc!=2)\r\n {\r\n printf(\"Usage is: writethrougasync\\n\");\r\n printf(\"Example: writethrougasync destfile.dat \\n\");\r\n return -1;\r\n }\r\n\r\n \/\/ Initialisation des diff\u00e9rents objets n\u00e9cessaires: OLs, events, HANDLES, etc... ------------------------------\r\n OVERLAPPED olwrite[MAXOUTSTANDINGIO]; \/\/ Ol IO pour l'\u00e9criture\r\n HANDLE hEvents[MAXOUTSTANDINGIO]; \/\/ tableau pour stocker les events \u00e9critures\r\n\r\n HANDLE hOutput; \/\/ HANDLE fichier dest\r\n LARGE_INTEGER OffsethOutput; \/\/ (Offsets,OffsetHigh) olwrite \r\n\r\n DWORD dwBytesWritten[MAXOUTSTANDINGIO]; \/\/ Nb octets lus par olwrite\r\n LONGLONG llTotalBytesWritten=0; \/\/ Quantit\u00e9 totale d'octets \u00e9crits\r\n BOOL isASYNCWRITE=FALSE; \/\/ Flag de contr\u00f4le IO async \/ sync pour les \u00e9critures\r\n int NBIOCOMPLETED=0; \/\/ Compteur d'IOs termin\u00e9es\r\n DWORD dwEventSignPos=0; \/\/ Index de l'event signal\u00e9 retourn\u00e9 par WaitForMultipleObjects()\r\n\r\n \/\/ R\u00e9cup\u00e9ration de la taille du secteur disque avec un IOCTL ---------------------------------------------------\r\n DISK_GEOMETRY dg;\r\n HANDLE hDrive;\r\n DWORD ioctlJnk; \r\n\r\n hDrive=CreateFile(TEXT(\"\\\\\\\\.\\\\PhysicalDrive0\")\r\n ,0\r\n ,FILE_SHARE_READ\r\n | FILE_SHARE_WRITE\r\n ,NULL\r\n ,OPEN_EXISTING\r\n ,0\r\n ,NULL);\r\n\r\n if (INVALID_HANDLE_VALUE==hDrive)\r\n {\r\n printf(\"Unable to open drive PhysicalDrive0. Last error=%d\\n\",GetLastError());\r\n return 1;\r\n }\r\n\r\n if (! DeviceIoControl(hDrive\r\n ,IOCTL_DISK_GET_DRIVE_GEOMETRY\r\n ,NULL\r\n ,0\r\n ,&dg\r\n ,sizeof(dg)\r\n ,&ioctlJnk\r\n ,NULL) )\r\n {\r\n printf(\"Error on IOCTL (IOCTL_DISK_GET_DRIVE_GEOMETRY) to %s. Last error=%d\\n\",argv[1],GetLastError());\r\n return 1;\r\n }\r\n\r\n CloseHandle(hDrive);\r\n\r\n \/\/ Ouverture du fichier cible en write-though \/ no buffering \/ Overlapped -------------------------------------\r\n hOutput = CreateFile(argv[1]\r\n ,GENERIC_READ\r\n | GENERIC_WRITE\r\n ,0\r\n ,NULL\r\n ,CREATE_ALWAYS\r\n ,FILE_ATTRIBUTE_NORMAL\r\n | FILE_FLAG_NO_BUFFERING\r\n | FILE_FLAG_WRITE_THROUGH\r\n | FILE_FLAG_OVERLAPPED\r\n ,NULL);\r\n\r\n if (INVALID_HANDLE_VALUE==hOutput)\r\n {\r\n printf(\"Unable to open output file %S. Last error=%d\\n\",argv[1],GetLastError());\r\n return -1;\r\n }\r\n\r\n \/\/ Initialisation du tampon --------------------------------------------------------------------------------\r\n wchar_t *csBuffer = (wchar_t *)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,dg.BytesPerSector * sizeof(wchar_t));\r\n int len = swprintf_s(csBuffer,dg.BytesPerSector,L\"abcdefghijklmnopqrstuvwxyz\"); \r\n\r\n \/\/ On initialise les events\r\n for(int i=0;i<\/pre>\n\n
R\u00e9sum\u00e9:<\/h2>\n
\n
Biblio:<\/h2>\n
\nFloundercraft<\/a>: a Joseph M. Newcomer resource
\nhttp:\/\/download.microsoft.com\/download\/6\/E\/8\/6E882A06-B71B-4642-9EB4-D1EA0D6223C8\/SQL%20Server%20IO%20Reliability%20Program%20Requirements%20Document.docx<\/a> : SQL Server I\/O Reliability Program Review.<\/p>\nNotes:<\/h2>\n
\n[2] en dehors de ReadFileEx et WriteFileEx qui sont r\u00e9serv\u00e9es aux I\/Os asynchrones.<\/p>\n<\/a><\/a><\/a>","protected":false},"excerpt":{"rendered":"