🆖 🤹🏾 🈲 OutOfMemory और GDI + कभी-कभी OutOfMemory बिल्कुल नहीं 😶 💕 🤙

काम पर अंतिम परियोजना को निष्पादित करते समय, मेरे सहकर्मी और मैंने इस तथ्य का सामना किया कि System.Drawing में कुछ तरीके और निर्माता पूरी तरह से सामान्य स्थानों में OutOfMemory से गिरते हैं, और जब अभी भी बहुत, बहुत मुक्त स्मृति है।

समस्या का सार

उदाहरण के लिए, यह C # कोड लें:

using System.Drawing; using System.Drawing.Drawing2D; namespace TempProject { static class Program { static void Main() { var point1 = new PointF(-3.367667E-16f, 0f); var point2 = new PointF(3.367667E-16f, 100f); var brush = new LinearGradientBrush(point1, point2, Color.White, Color.Black); } } }

जब अंतिम पंक्ति निष्पादित की जाती है, तो एक आउटऑफ़मेमोरी अपवाद को फेंकने की गारंटी दी जाती है, भले ही कितनी मुफ्त मेमोरी उपलब्ध हो। इसके अलावा, यदि आप 3.367667E-16f और -3.367667E-16f को 0 से बदलते हैं, जो सत्य के बहुत करीब है, तो सब कुछ ठीक चलेगा - भरण का निर्माण होगा। मेरी राय में, यह व्यवहार अजीब लगता है। आइए देखें कि यह क्यों हो रहा है और इससे कैसे निपटना है।

रोग के कारणों का पता लगाएं

के साथ शुरू करने के लिए, हम सीखते हैं कि LinearGradientBrush कंस्ट्रक्टर में क्या होता है। ऐसा करने के लिए, आप referenceource.microsoft.com पर देख सकते हैं। निम्नलिखित होंगे:

 public LinearGradientBrush(PointF point1, PointF point2, Color color1, Color color2) { IntPtr brush = IntPtr.Zero; int status = SafeNativeMethods.Gdip.GdipCreateLineBrush( new GPPOINTF(point1), new GPPOINTF(point2), color1.ToArgb(), color2.ToArgb(), (int)WrapMode.Tile, out brush ); if (status != SafeNativeMethods.Gdip.Ok) throw SafeNativeMethods.Gdip.StatusException(status); SetNativeBrushInternal(brush); }

यह नोटिस करना आसान है कि यहां सबसे महत्वपूर्ण बात GdipCreateLineBrush पद्धति का GDI + कॉल है। तो, आपको यह देखने की जरूरत है कि इसके अंदर क्या हो रहा है। ऐसा करने के लिए, IDA + HexRays का उपयोग करें। आईडीए gdiplus.dll पर डाउनलोड करें। यदि आपको लाइब्रेरी के किस संस्करण को डीबग करने के लिए निर्धारित करने की आवश्यकता है, तो आप SysInternals से प्रोसेस एक्सप्लोरर का उपयोग कर सकते हैं। इसके अलावा, आप उस फ़ोल्डर पर अनुमतियों के साथ समस्याओं का अनुभव कर सकते हैं जहाँ gdiplus.dll निहित है। वे इस फ़ोल्डर के स्वामी को बदलकर हल कर रहे हैं।

तो, आईडीए में gdiplus.dll खोलें। चलो फ़ाइल संसाधित होने की प्रतीक्षा करें। उसके बाद, मेनू में सेलेक्ट करें: व्यू → ओपन सब्जेक्ट्स → इस लाइब्रेरी से एक्सपोर्ट होने वाले सभी फंक्शन्स को खोलने के लिए एक्सपोर्ट करें और वहां GdipCreateLineBrush ढूंढें।

अक्षर लोड करने के लिए धन्यवाद, HexRays और प्रलेखन की शक्ति, आप कोड कोड से विधि कोड को आसानी से पढ़ने योग्य ++ में अनुवाद कर सकते हैं:

GdipCreateLineBrush

 GpStatus __userpurge GdipCreateLineBrush@<eax>(int a1@<edi>, GpPointF *point1, GpPointF *point2, int color1, int color2, int wrapMode, GpRectGradient **result) { GpStatus status; // esi MAPDST GpGradientBrush *v8; // eax GpRectGradient *v9; // eax int v12; // [esp+4h] [ebp-Ch] int vColor1; // [esp+8h] [ebp-8h] int vColor2; // [esp+Ch] [ebp-4h] FPUStateSaver::FPUStateSaver(&v12, 1); EnterCriticalSection(&GdiplusStartupCriticalSection::critSec); if ( Globals::LibraryInitRefCount > 0 ) { LeaveCriticalSection(&GdiplusStartupCriticalSection::critSec); if ( result && point1 && point2 && wrapMode != 4 ) { vColor1 = color1; vColor2 = color2; v8 = operator new(a1); status = 0; if ( v8 ) v9 = GpLineGradient::GpLineGradient(v8, point1, point2, &vColor1, &vColor2, wrapMode); else v9 = 0; *result = v9; if ( !CheckValid<GpHatch>(result) ) status = OutOfMemory; } else { status = InvalidParameter; } } else { LeaveCriticalSection(&GdiplusStartupCriticalSection::critSec); status = GdiplusNotInitialized; } __asm { fclex } return status; }

इस पद्धति का कोड पूरी तरह से स्पष्ट है। इसका सार लाइनों में निहित है:

 if ( result && point1 && point2 && wrapMode != 4 ) { vColor1 = color1; vColor2 = color2; v8 = operator new(a1); status = 0; if ( v8 ) v9 = GpLineGradient::GpLineGradient(v8, point1, point2, &vColor1, &vColor2, wrapMode); else v9 = 0; *result = v9; if ( !CheckValid<GpHatch>(result) ) status = OutOfMemory } else { status = InvalidParameter; }

यदि इनपुट पैरामीटर सही हैं, और यदि यह नहीं है, तो GdiPlus जाँचता है, तो एक InvalidParameter वापस करता है। अन्यथा, एक GpLineGradient वैधता के लिए बनाया और जाँच की जाती है। यदि सत्यापन विफल रहता है, तो OutOfMemory लौटा दी जाती है। जाहिरा तौर पर, यह हमारा मामला है, और इसलिए, हमें यह पता लगाने की जरूरत है कि GpLineGradio निर्माण के अंदर क्या हो रहा है:

GpLineGradient :: GpLineGradient

 GpRectGradient *__thiscall GpLineGradient::GpLineGradient(GpGradientBrush *this, GpPointF *point1, GpPointF *point2, int color1, int color2, int wrapMode) { GpGradientBrush *v6; // esi float height; // ST2C_4 double v8; // st7 float width; // ST2C_4 float angle; // ST2C_4 GpRectF rect; // [esp+1Ch] [ebp-10h] v6 = this; GpGradientBrush::GpGradientBrush(this); GpRectGradient::DefaultBrush(v6); rect.Height = 0.0; rect.Width = 0.0; rect.Y = 0.0; rect.X = 0.0; *v6 = &GpLineGradient::`vftable; if ( LinearGradientRectFromPoints(point1, point2, &rect) ) { *(v6 + 1) = 1279869254; } else { height = point2->Y - point1->Y; v8 = height; width = point2->X - point1->X; angle = atan2(v8, width) * 180.0 / 3.141592653589793; GpLineGradient::SetLineGradient(v6, point1, point2, &rect, color1, color2, angle, 0, wrapMode); } return v6; }

यहाँ वैरिएबल्स को इनिशियलाइज़ किया गया है, जो फिर LinearGradientRectFromPoints और SetLineGradient में भरे गए हैं। मैं यह मानने की हिम्मत करता हूं कि बिंदु, बिंदु 1 और बिंदु 2 पर आधारित एक भरण आयत है, इसे देखने के लिए, आप LinearGradientRectFromPoints पर देख सकते हैं:

LinearGradientRectFromPoints

 GpStatus __fastcall LinearGradientRectFromPoints(GpPointF *p1, GpPointF *p2, GpRectF *result) { double vP1X; // st7 float vLeft; // ST1C_4 MAPDST double vP1Y; // st7 float vTop; // ST1C_4 MAPDST float vWidth; // ST18_4 MAPDST double vWidth3; // st7 float vHeight; // ST18_4 MAPDST float vP2X; // [esp+18h] [ebp-8h] float vP2Y; // [esp+1Ch] [ebp-4h] if ( IsClosePointF(p1, p2) ) return InvalidParameter; vP2X = p2->X; vP1X = p1->X; if ( vP2X <= vP1X ) vP1X = vP2X; vLeft = vP1X; result->X = vLeft; vP2Y = p2->Y; vP1Y = p1->Y; if ( vP2Y <= vP1Y ) vP1Y = vP2Y; vTop = vP1Y; result->Y = vTop; vWidth = p1->X - p2->X; vWidth = fabs(vWidth); vWidth3 = vWidth; result->Width = vWidth; vHeight = p1->Y - p2->Y; vHeight = fabs(vHeight); result->Height = vHeight; vWidth = vWidth3; if ( IsCloseReal(p1->X, p2->X) ) { result->X = vLeft - 0.5 * vHeight; result->Width = vHeight; vWidth = vHeight; } if ( IsCloseReal(p1->Y, p2->Y) ) { result->Y = vTop - vWidth * 0.5; result->Height = vWidth; } return 0; }

जैसा कि अपेक्षित था, पॉइंट पॉइंट 1 और पॉइंट 2 की आयत है।

अब हम अपनी मुख्य समस्या पर वापस आते हैं और देखते हैं कि SetLineGradient के अंदर क्या होता है:

SetLineGradient

 GpStatus __thiscall GpLineGradient::SetLineGradient(DpGradientBrush *this, GpPointF *p1, GpPointF *p2, GpRectF *rect, int color1, int color2, float angle, int zero, int wrapMode) { _DWORD *v10; // edi float *v11; // edi GpStatus v12; // esi _DWORD *v14; // edi this->wrapMode = wrapMode; v10 = &this->dword40; this->Color1 = *color1; this->Color2 = *color2; this->Color11 = *color1; this->Color21 = *color2; this->dwordB0 = 0; this->float98 = 1.0; this->dwordA4 = 1; this->dwordA0 = 1; this->float94 = 1.0; this->dwordAC = 0; if ( CalcLinearGradientXform(zero, rect, angle, &this->gap4[16]) ) { *this->gap4 = 1279869254; *v10 = 0; v14 = v10 + 1; *v14 = 0; ++v14; *v14 = 0; v14[1] = 0; *&this[1].gap4[12] = 0; *&this[1].gap4[16] = 0; *&this[1].gap4[20] = 0; *&this[1].gap4[24] = 0; *&this->gap44[28] = 0; v12 = InvalidParameter; } else { *this->gap4 = 1970422321; *v10 = LODWORD(rect->X); v11 = (v10 + 1); *v11 = rect->Y; ++v11; *v11 = rect->Width; v11[1] = rect->Height; *&this->gap44[28] = zero; v12 = 0; *&this[1].gap4[12] = *p1; *&this[1].gap4[20] = *p2; } return v12; }

SetLineGradient में भी, केवल फ़ील्ड इनिशियलाइज़ेशन होता है। तो, हमें गहराई तक जाने की आवश्यकता है:

 int __fastcall CalcLinearGradientXform(int zero, GpRectF *rect, float angle, int a4) { //... //... //... return GpMatrix::InferAffineMatrix(a4, points, rect) != OK ? InvalidParameter : OK; }

और अंत में:

 GpStatus __thiscall GpMatrix::InferAffineMatrix(int this, GpPointF *points, GpRectF *rect) { //... double height; // st6 double y; // st5 double width; // st4 double x; // st3 double bottom; // st2 float right; // ST3C_4 float rectArea; // ST3C_4 //... x = rect->X; y = rect->Y; width = rect->Width; height = rect->Height; right = x + width; bottom = height + y; rectArea = bottom * right - x * y - (y * width + x * height); rectArea = fabs(rectArea); if ( rectArea < 0.00000011920929 ) return InvalidParameter; //... }

InferAffineMatrix विधि बिल्कुल वही है जो हमें रुचती है। यहां रेक्ट के क्षेत्र की जाँच की जाती है - अंकों की मूल आयत, और यदि यह 0.00000011920929 से कम है, तो InferAffineMatrix, InvalidParameter को लौटाता है। 0.00000011920929 फ्लोट (FLT_EPSILON) के लिए मशीन एप्सिलॉन है । आप देख सकते हैं कि Microsoft आयत के क्षेत्र को कितना दिलचस्प मानता है:

 rectArea = bottom * right - x * y - (y * width + x * height);

क्षेत्र से निचले दाईं ओर, क्षेत्र को ऊपरी बाईं ओर घटाएं, फिर आयत के ऊपर के क्षेत्र और आयत के बाईं ओर के क्षेत्र को घटाएं। ऐसा क्यों किया जाता है, मुझे समझ नहीं आता; मुझे उम्मीद है कि किसी दिन मुझे यह गुप्त विधि पता चल जाएगी।

तो हमारे पास क्या है:

इनरएफ़ाइनमैट्रिक्स ने इनवैलिडपैरेट रिटर्न किया;
CalcLinearGradientXForm इस परिणाम को अधिक फेंकता है;
SetLineGradient में, निष्पादन यदि शाखा का अनुसरण करेगा, और विधि भी InvalidParameter वापस आ जाएगी;
GpLineGradient निर्माता InvalidParameter के बारे में जानकारी खो देगा और एक GpLineGradient ऑब्जेक्ट लौटाएगा जो अंत तक आरंभीकृत नहीं है - यह बहुत बुरा है!
GdipCreateLineBrush CheckValid (लाइन 26) में जाँच करेगा कि GpLineGradient ऑब्जेक्ट उन फ़ील्ड्स के साथ मान्य है जो पूरी तरह से भरे हुए नहीं हैं और स्वाभाविक रूप से गलत वापस आएंगे।
उसके बाद, स्थिति OutOfMemory में बदल जाएगी, जिसे GDI + विधि से बाहर निकलने पर .NET मिलेगा।

यह पता चला है कि Microsoft किसी कारण से कुछ तरीकों की वापसी स्थिति को अनदेखा करता है, इस वजह से गलत धारणा बनाता है, और अन्य प्रोग्रामर के लिए लाइब्रेरी के काम की समझ को जटिल करता है। लेकिन आपको बस इतना करना था कि स्टेट को GpLineGradient कंस्ट्रक्टर से ऊँचा फेंका जाए, और GdipCreateLineBrush में ओके में रिटर्न वैल्यू चेक करें और अन्यथा कंस्ट्रक्टर का स्टेटस वापस करें। फिर, GDI + उपयोगकर्ताओं के लिए, लाइब्रेरी के अंदर होने वाला त्रुटि संदेश अधिक तार्किक लगेगा।

शून्य के साथ बहुत कम संख्याओं को बदलने का विकल्प, अर्थात। ऊर्ध्वाधर भरण के साथ, यह उस त्रुटि के बिना चलता है, जिस कारण Microsoft लाइनरग्रैडिएंटRectFromPoints पद्धति में 45 के माध्यम से Microsoft करता है:

जादू

 if ( IsCloseReal(p1->X, p2->X) ) { result->X = vLeft - 0.5 * vHeight; result->Width = vHeight; vWidth = vHeight; } if ( IsCloseReal(p1->Y, p2->Y) ) { result->Y = vTop - vWidth * 0.5; result->Height = vWidth; }

कैसे करें इलाज?

.NET कोड में इस क्रैश से कैसे बचें? सबसे सरल और सबसे स्पष्ट विकल्प यह है कि आयत के क्षेत्र की तुलना पॉइंट 1 और पॉइंट 2 से FLT_EPSILON से की जाए और क्षेत्र छोटा होने पर ग्रेडिएंट न बनाया जाए। लेकिन इस विकल्प के साथ, हम ढाल के बारे में जानकारी खो देंगे, और एक अनपेक्षित क्षेत्र खींचा जाएगा, जो अच्छा नहीं है। मुझे ग्रेडिएंट फिल के कोण की जांच करते समय एक अधिक स्वीकार्य विकल्प दिखाई देता है, और यदि यह पता चलता है कि भरण क्षैतिज या ऊर्ध्वाधर के करीब है, तो अंक के लिए संबंधित पैरामीटर समान सेट करें:

C # में मेरा समाधान

 static LinearGradientBrush CreateBrushSafely(PointF p1, PointF p2) { if(IsShouldNormalizePoints(p1, p2)) { if(!NormalizePoints(ref p1, ref p2)) return null; } var brush = new LinearGradientBrush(p1, p2, Color.White, Color.Black); return brush; } static bool IsShouldNormalizePoints(PointF p1, PointF p2) { float width = Math.Abs(p1.X - p2.X); float height = Math.Abs(p1.Y - p2.Y); return width * height < FLT_EPSILON && !(IsCloseFloat(p1.X, p2.X) || IsCloseFloat(p1.Y, p2.Y)); } static bool IsCloseFloat(float v1, float v2) { var t = v2 == 0.0f ? 1.0f : v2; return Math.Abs((v1 - v2) / t) < FLT_EPSILON; } static bool NormalizePoints(ref PointF p1, ref PointF p2) { const double twoDegrees = 0.03490658503988659153847381536977d; float width = Math.Abs(p1.X - p2.X); float height = Math.Abs(p1.Y - p2.Y); var angle = Math.Atan2(height, width); if (Math.Abs(angle) < twoDegrees) { p1.Y = p2.Y; return true; } if (Math.Abs(angle - Math.PI / 2) < twoDegrees) { p1.X = p2.X; return true; } return false; }

प्रतियोगी कैसे कर रहे हैं?

आइए जानें शराब में क्या चल रहा है। ऐसा करने के लिए , शराब के स्रोत कोड को देखें , लाइन 306:

शराब का GdipCreateLineBrush

 /****************************************************************************** * GdipCreateLineBrush [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint, GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line) { TRACE("(%s, %s, %x, %x, %d, %p)\n", debugstr_pointf(startpoint), debugstr_pointf(endpoint), startcolor, endcolor, wrap, line); if(!line || !startpoint || !endpoint || wrap == WrapModeClamp) return InvalidParameter; if (startpoint->X == endpoint->X && startpoint->Y == endpoint->Y) return OutOfMemory; *line = heap_alloc_zero(sizeof(GpLineGradient)); if(!*line) return OutOfMemory; (*line)->brush.bt = BrushTypeLinearGradient; (*line)->startpoint.X = startpoint->X; (*line)->startpoint.Y = startpoint->Y; (*line)->endpoint.X = endpoint->X; (*line)->endpoint.Y = endpoint->Y; (*line)->startcolor = startcolor; (*line)->endcolor = endcolor; (*line)->wrap = wrap; (*line)->gamma = FALSE; (*line)->rect.X = (startpoint->X < endpoint->X ? startpoint->X: endpoint->X); (*line)->rect.Y = (startpoint->Y < endpoint->Y ? startpoint->Y: endpoint->Y); (*line)->rect.Width = fabs(startpoint->X - endpoint->X); (*line)->rect.Height = fabs(startpoint->Y - endpoint->Y); if ((*line)->rect.Width == 0) { (*line)->rect.X -= (*line)->rect.Height / 2.0f; (*line)->rect.Width = (*line)->rect.Height; } else if ((*line)->rect.Height == 0) { (*line)->rect.Y -= (*line)->rect.Width / 2.0f; (*line)->rect.Height = (*line)->rect.Width; } (*line)->blendcount = 1; (*line)->blendfac = heap_alloc_zero(sizeof(REAL)); (*line)->blendpos = heap_alloc_zero(sizeof(REAL)); if (!(*line)->blendfac || !(*line)->blendpos) { heap_free((*line)->blendfac); heap_free((*line)->blendpos); heap_free(*line); *line = NULL; return OutOfMemory; } (*line)->blendfac[0] = 1.0f; (*line)->blendpos[0] = 1.0f; (*line)->pblendcolor = NULL; (*line)->pblendpos = NULL; (*line)->pblendcount = 0; linegradient_init_transform(*line); TRACE("<-- %p\n", *line); return Ok; }

यहाँ मापदंडों का एकमात्र सत्यापन है:

 if(!line || !startpoint || !endpoint || wrap == WrapModeClamp) return InvalidParameter;

सबसे अधिक संभावना है, विंडोज के साथ संगतता के लिए निम्नलिखित लिखा गया है:

 if (startpoint->X == endpoint->X && startpoint->Y == endpoint->Y) return OutOfMemory;

और बाकी कुछ भी दिलचस्प नहीं है - मेमोरी आवंटन और खेतों में भरना। स्रोत कोड से, यह स्पष्ट हो जाता है कि वाइन में त्रुटियों के बिना एक समस्या ढाल भरने का निर्माण किया जाना चाहिए। और वास्तव में - यदि आप विंडोज पर निम्न प्रोग्राम चलाते हैं (मैं Windows10x64 पर चला)

परीक्षण कार्यक्रम

 #include <Windows.h> #include "stdafx.h" #include <gdiplus.h> #include <iostream> #pragma comment(lib,"gdiplus.lib") void CreateBrush(float x1, float x2) { Gdiplus::LinearGradientBrush linGrBrush( Gdiplus::PointF(x1, -0.5f), Gdiplus::PointF(x2, 10.5f), Gdiplus::Color(255, 0, 0, 0), Gdiplus::Color(255, 255, 255, 255)); const int status = linGrBrush.GetLastStatus(); const char* result; if (status == 3) { result = "OutOfMemory"; } else { result = "Ok"; } std::cout << result << "\n"; } int main() { Gdiplus::GdiplusStartupInput gdiplusStartupInput; ULONG_PTR gdiplusToken; Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL); Gdiplus::Graphics myGraphics(GetDC(0)); CreateBrush(-3.367667E-16f, 3.367667E-16f); CreateBrush(0, 0); return 0; }

विंडोज कंसोल में यह होगा:

OutOfMemory
ठीक है

और शराब के साथ उबंटू में:

ठीक है
ठीक है

यह पता चला है कि या तो मैं कुछ गलत कर रहा हूं, या इस मामले में वाइन विंडोज की तुलना में अधिक तार्किक रूप से काम करता है।

निष्कर्ष

मैं वास्तव में आशा करता हूं कि मुझे कुछ समझ नहीं आया और GDI + का व्यवहार तर्कसंगत है। सच है, यह बिल्कुल स्पष्ट नहीं है कि माइक्रोसॉफ्ट ने ऐसा क्यों किया। मैंने उनके अन्य उत्पादों में बहुत विलम्ब किया है, और ऐसी चीजें भी हैं जो एक सभ्य समाज में कोड रिव्यू को पारित नहीं करेंगे।

OutOfMemory और GDI + कभी-कभी OutOfMemory बिल्कुल नहीं

समस्या का सार

रोग के कारणों का पता लगाएं

कैसे करें इलाज?

प्रतियोगी कैसे कर रहे हैं?

निष्कर्ष

More articles: