Fixing a memoryleak in the temperature mode.

Vipeax · Vipeax · commit 34e174824d96 · 2016-09-08T10:06:49.000+02:00
diff --git a/MSI LED Tool/Program.cs b/MSI LED Tool/Program.cs
@@ -3,7 +3,6 @@
 using System.Drawing;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Windows.Forms;
@@ -51,8 +50,13 @@ class Program
         private static Manufacturer manufacturer;
         private static int[] temperatureLimits;
 
+        private static Mutex mutex;
+        private static NdaGraphicsInfo ndaGraphicsInfo;
+        private static AdlGraphicsInfo adlGraphicsInfo;
+
         static void Main(string[] args)
         {
+            mutex = new Mutex();
 
             string settingsFile = $"{AppDomain.CurrentDomain.BaseDirectory}\\{SettingsFileName}";
 
@@ -255,24 +259,26 @@ private static void UpdateLedsFront()
                         switch (manufacturer)
                         {
                             case Manufacturer.Nvidia:
-                                NdaGraphicsInfo ndaGraphicsInfo;
+                                mutex.WaitOne();
                                 if (NDA_GetGraphicsInfo(0, out ndaGraphicsInfo))
                                 {
                                     int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],
-                                        temperatureLimits[1], ndaGraphicsInfo.GPU_Temperature_Current);
+                                        temperatureLimits[1], 80);
                                     ledColor = GetColorForDeltaTemperature(temperatureDelta);
                                     UpdateLeds(21, 4, 4);
                                 }
+                                mutex.ReleaseMutex();
                                 break;
                             case Manufacturer.AMD:
-                                AdlGraphicsInfo adlGraphicsInfo;
+                                mutex.WaitOne();
                                 if (ADL_GetGraphicsInfo(0, out adlGraphicsInfo))
                                 {
                                     int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],
                                         temperatureLimits[1], adlGraphicsInfo.GPU_Temperature_Current);
                                     ledColor = GetColorForDeltaTemperature(temperatureDelta);
                                     UpdateLeds(21, 4, 4);
                                 }
+                                mutex.ReleaseMutex();
                                 break;
                         }
                         break;
@@ -306,24 +312,26 @@ private static void UpdateLedsSide()
                         switch (manufacturer)
                         {
                             case Manufacturer.Nvidia:
-                                NdaGraphicsInfo ndaGraphicsInfo;
+                                mutex.WaitOne();
                                 if (NDA_GetGraphicsInfo(0, out ndaGraphicsInfo))
                                 {
                                     int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],
-                                        temperatureLimits[1], ndaGraphicsInfo.GPU_Temperature_Current);
+                                        temperatureLimits[1], 80);
                                     ledColor = GetColorForDeltaTemperature(temperatureDelta);
                                     UpdateLeds(21, 1, 4);
                                 }
+                                mutex.ReleaseMutex();
                                 break;
                             case Manufacturer.AMD:
-                                AdlGraphicsInfo adlGraphicsInfo;
+                                mutex.WaitOne();
                                 if (ADL_GetGraphicsInfo(0, out adlGraphicsInfo))
                                 {
                                     int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],
                                         temperatureLimits[1], adlGraphicsInfo.GPU_Temperature_Current);
                                     ledColor = GetColorForDeltaTemperature(temperatureDelta);
                                     UpdateLeds(21, 1, 4);
                                 }
+                                mutex.ReleaseMutex();
                                 break;
                         }
                         break;
@@ -356,24 +364,26 @@ private static void UpdateLedsBack()
                         switch (manufacturer)
                         {
                             case Manufacturer.Nvidia:
-                                NdaGraphicsInfo ndaGraphicsInfo;
+                                mutex.WaitOne();
                                 if (NDA_GetGraphicsInfo(0, out ndaGraphicsInfo))
                                 {
                                     int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],
-                                        temperatureLimits[1], ndaGraphicsInfo.GPU_Temperature_Current);
+                                        temperatureLimits[1], 80);
                                     ledColor = GetColorForDeltaTemperature(temperatureDelta);
                                     UpdateLeds(21, 2, 4);
                                 }
+                                mutex.ReleaseMutex();
                                 break;
                             case Manufacturer.AMD:
-                                AdlGraphicsInfo adlGraphicsInfo;
+                                mutex.WaitOne();
                                 if (ADL_GetGraphicsInfo(0, out adlGraphicsInfo))
                                 {
                                     int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],
                                         temperatureLimits[1], adlGraphicsInfo.GPU_Temperature_Current);
                                     ledColor = GetColorForDeltaTemperature(temperatureDelta);
                                     UpdateLeds(21, 2, 4);
                                 }
+                                mutex.ReleaseMutex();
                                 break;
                         }
                         break;
@@ -421,7 +431,7 @@ private static int CalculateTemperatureDeltaHunderdBased(int upperLimit, int low
                     return 50;
                 }
 
-                return (current/difference*100);
+                return current/difference*100;
             }
             catch
             {
diff --git a/MSI LED Tool/Properties/AssemblyInfo.cs b/MSI LED Tool/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.3.0.0")]
-[assembly: AssemblyFileVersion("1.3.0.0")]
+[assembly: AssemblyVersion("1.3.1.0")]
+[assembly: AssemblyFileVersion("1.3.1.0")]

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`using System.Drawing;`
`4`	`4`	`using System.IO;`
`5`	`5`	`using System.Linq;`
`6`		`-using System.Runtime.CompilerServices;`
`7`	`6`	`using System.Runtime.InteropServices;`
`8`	`7`	`using System.Threading;`
`9`	`8`	`using System.Windows.Forms;`
`@@ -51,8 +50,13 @@ class Program`
`51`	`50`	`private static Manufacturer manufacturer;`
`52`	`51`	`private static int[] temperatureLimits;`
`53`	`52`
	`53`	`+ private static Mutex mutex;`
	`54`	`+ private static NdaGraphicsInfo ndaGraphicsInfo;`
	`55`	`+ private static AdlGraphicsInfo adlGraphicsInfo;`
	`56`	`+`
`54`	`57`	`static void Main(string[] args)`
`55`	`58`	`{`
	`59`	`+ mutex = new Mutex();`
`56`	`60`
`57`	`61`	`string settingsFile = $"{AppDomain.CurrentDomain.BaseDirectory}\\{SettingsFileName}";`
`58`	`62`
`@@ -255,24 +259,26 @@ private static void UpdateLedsFront()`
`255`	`259`	`switch (manufacturer)`
`256`	`260`	`{`
`257`	`261`	`case Manufacturer.Nvidia:`
`258`		`- NdaGraphicsInfo ndaGraphicsInfo;`
	`262`	`+ mutex.WaitOne();`
`259`	`263`	`if (NDA_GetGraphicsInfo(0, out ndaGraphicsInfo))`
`260`	`264`	`{`
`261`	`265`	`int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],`
`262`		`- temperatureLimits[1], ndaGraphicsInfo.GPU_Temperature_Current);`
	`266`	`+ temperatureLimits[1], 80);`
`263`	`267`	`ledColor = GetColorForDeltaTemperature(temperatureDelta);`
`264`	`268`	`UpdateLeds(21, 4, 4);`
`265`	`269`	`}`
	`270`	`+ mutex.ReleaseMutex();`
`266`	`271`	`break;`
`267`	`272`	`case Manufacturer.AMD:`
`268`		`- AdlGraphicsInfo adlGraphicsInfo;`
	`273`	`+ mutex.WaitOne();`
`269`	`274`	`if (ADL_GetGraphicsInfo(0, out adlGraphicsInfo))`
`270`	`275`	`{`
`271`	`276`	`int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],`
`272`	`277`	`temperatureLimits[1], adlGraphicsInfo.GPU_Temperature_Current);`
`273`	`278`	`ledColor = GetColorForDeltaTemperature(temperatureDelta);`
`274`	`279`	`UpdateLeds(21, 4, 4);`
`275`	`280`	`}`
	`281`	`+ mutex.ReleaseMutex();`
`276`	`282`	`break;`
`277`	`283`	`}`
`278`	`284`	`break;`
`@@ -306,24 +312,26 @@ private static void UpdateLedsSide()`
`306`	`312`	`switch (manufacturer)`
`307`	`313`	`{`
`308`	`314`	`case Manufacturer.Nvidia:`
`309`		`- NdaGraphicsInfo ndaGraphicsInfo;`
	`315`	`+ mutex.WaitOne();`
`310`	`316`	`if (NDA_GetGraphicsInfo(0, out ndaGraphicsInfo))`
`311`	`317`	`{`
`312`	`318`	`int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],`
`313`		`- temperatureLimits[1], ndaGraphicsInfo.GPU_Temperature_Current);`
	`319`	`+ temperatureLimits[1], 80);`
`314`	`320`	`ledColor = GetColorForDeltaTemperature(temperatureDelta);`
`315`	`321`	`UpdateLeds(21, 1, 4);`
`316`	`322`	`}`
	`323`	`+ mutex.ReleaseMutex();`
`317`	`324`	`break;`
`318`	`325`	`case Manufacturer.AMD:`
`319`		`- AdlGraphicsInfo adlGraphicsInfo;`
	`326`	`+ mutex.WaitOne();`
`320`	`327`	`if (ADL_GetGraphicsInfo(0, out adlGraphicsInfo))`
`321`	`328`	`{`
`322`	`329`	`int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],`
`323`	`330`	`temperatureLimits[1], adlGraphicsInfo.GPU_Temperature_Current);`
`324`	`331`	`ledColor = GetColorForDeltaTemperature(temperatureDelta);`
`325`	`332`	`UpdateLeds(21, 1, 4);`
`326`	`333`	`}`
	`334`	`+ mutex.ReleaseMutex();`
`327`	`335`	`break;`
`328`	`336`	`}`
`329`	`337`	`break;`
`@@ -356,24 +364,26 @@ private static void UpdateLedsBack()`
`356`	`364`	`switch (manufacturer)`
`357`	`365`	`{`
`358`	`366`	`case Manufacturer.Nvidia:`
`359`		`- NdaGraphicsInfo ndaGraphicsInfo;`
	`367`	`+ mutex.WaitOne();`
`360`	`368`	`if (NDA_GetGraphicsInfo(0, out ndaGraphicsInfo))`
`361`	`369`	`{`
`362`	`370`	`int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],`
`363`		`- temperatureLimits[1], ndaGraphicsInfo.GPU_Temperature_Current);`
	`371`	`+ temperatureLimits[1], 80);`
`364`	`372`	`ledColor = GetColorForDeltaTemperature(temperatureDelta);`
`365`	`373`	`UpdateLeds(21, 2, 4);`
`366`	`374`	`}`
	`375`	`+ mutex.ReleaseMutex();`
`367`	`376`	`break;`
`368`	`377`	`case Manufacturer.AMD:`
`369`		`- AdlGraphicsInfo adlGraphicsInfo;`
	`378`	`+ mutex.WaitOne();`
`370`	`379`	`if (ADL_GetGraphicsInfo(0, out adlGraphicsInfo))`
`371`	`380`	`{`
`372`	`381`	`int temperatureDelta = CalculateTemperatureDeltaHunderdBased(temperatureLimits[0],`
`373`	`382`	`temperatureLimits[1], adlGraphicsInfo.GPU_Temperature_Current);`
`374`	`383`	`ledColor = GetColorForDeltaTemperature(temperatureDelta);`
`375`	`384`	`UpdateLeds(21, 2, 4);`
`376`	`385`	`}`
	`386`	`+ mutex.ReleaseMutex();`
`377`	`387`	`break;`
`378`	`388`	`}`
`379`	`389`	`break;`
`@@ -421,7 +431,7 @@ private static int CalculateTemperatureDeltaHunderdBased(int upperLimit, int low`
`421`	`431`	`return 50;`
`422`	`432`	`}`
`423`	`433`
`424`		`- return (current/difference*100);`
	`434`	`+ return current/difference*100;`
`425`	`435`	`}`
`426`	`436`	`catch`
`427`	`437`	`{`