അതെ, എന്റെ പഴയ ലാപ്‌ടോപ്പ് നിങ്ങളുടെ പ്രൊഡക്ഷൻ സെർവറിനേക്കാൾ പലമടങ്ങ് ശക്തമാണ്

ഞങ്ങളുടെ ഡെവലപ്പർമാരിൽ നിന്ന് ഞാൻ കേട്ട പരാതികൾ ഇവയാണ്. ഏറ്റവും രസകരമായ കാര്യം, ഇത് ഒരു നീണ്ട അന്വേഷണത്തിന് കാരണമായിത്തീർന്നു എന്നതാണ്. VMware-ൽ പ്രവർത്തിക്കുന്ന SQL സെർവറുകളെ കുറിച്ച് നമ്മൾ സംസാരിക്കും.

യഥാർത്ഥത്തിൽ, പ്രൊഡക്ഷൻ സെർവർ നിരാശാജനകമായി ലാപ്‌ടോപ്പിന് പിന്നിലാണെന്ന് ഉറപ്പാക്കുന്നത് എളുപ്പമാണ്. കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക (ടെംപ്ഡിബിയിലല്ല, ഡിലേഡ് ഡ്യൂറബിലിറ്റി പ്രവർത്തനക്ഷമമാക്കിയ ഒരു ഡാറ്റാബേസിലല്ല):

set nocount on
create table _t (v varchar(100))
declare @n int=300000
while @n>0 begin 
  insert into _t select 'What a slowpoke!'
  delete from _t
  set @n=@n-1
  end
GO
drop table _t

എന്റെ ഡെസ്ക്ടോപ്പിൽ ഇത് 5 സെക്കൻഡ് എടുക്കും, പ്രൊഡക്ഷൻ സെർവറിൽ ഇത് 28 സെക്കൻഡ് എടുക്കും. കാരണം ഇടപാട് ലോഗ് എൻട്രിയുടെ ഫിസിക്കൽ എൻട്രിക്കായി SQL കാത്തിരിക്കണം, ഞങ്ങൾ ഇവിടെ വളരെ ചെറിയ ഇടപാടുകളാണ് നടത്തുന്നത്. ഏകദേശം പറഞ്ഞാൽ, ഞങ്ങൾ ഒരു വലിയ, ശക്തമായ ട്രക്ക് നഗരത്തിലെ ട്രാഫിക്കിലേക്ക് ഓടിച്ചു, സ്കൂട്ടറുകളിൽ പിസ്സ ഡെലിവറി ചെയ്യുന്ന ആളുകൾ അതിനെ അതിസാഹസികമായി മറികടക്കുന്നത് കണ്ടു - ഇവിടെ ത്രൂപുട്ട് പ്രധാനമല്ല, ലേറ്റൻസി മാത്രമാണ് പ്രധാനം. ഒരു നെറ്റ്‌വർക്ക് സ്റ്റോറേജിനും, അതിന്റെ വിലയിൽ എത്ര പൂജ്യങ്ങളുണ്ടെങ്കിലും, ലേറ്റൻസിയുടെ കാര്യത്തിൽ ലോക്കൽ SSD-യെ തോൽപ്പിക്കാൻ കഴിയില്ല.

(അഭിപ്രായങ്ങളിൽ ഞാൻ കള്ളം പറഞ്ഞതായി തെളിഞ്ഞു - രണ്ടിടത്തും ഞാൻ ഈടുനിൽക്കാൻ കാലതാമസം വരുത്തി. കാലതാമസമില്ലാതെ ഇത് മാറുന്നു:
ഡെസ്‌ക്‌ടോപ്പ് - 39 സെക്കൻഡ്, 15K tr/sec, 0.065ms /io റൗണ്ട്‌ട്രിപ്പ്
PROD - 360 സെക്കൻഡ്, 1600 tr/sec, 0.6ms
ഇത് വളരെ വേഗതയുള്ളതാണെന്ന് ഞാൻ ശ്രദ്ധിക്കേണ്ടതായിരുന്നു)

എന്നിരുന്നാലും, ഈ സാഹചര്യത്തിൽ ഞങ്ങൾ ഒരു നിസ്സാര ഉദാഹരണം ഉപയോഗിച്ച് റീമാൻ സീറ്റ ഫംഗ്‌ഷന്റെ നിസ്സാര പൂജ്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നു. ഡവലപ്പർമാർ എന്നെ കൊണ്ടുവന്ന ഉദാഹരണത്തിൽ, അത് വ്യത്യസ്തമായിരുന്നു. അവർ പറഞ്ഞത് ശരിയാണെന്ന് എനിക്ക് ബോധ്യപ്പെട്ടു, ബിസിനസ്സ് യുക്തിയുമായി ബന്ധപ്പെട്ട എല്ലാ സവിശേഷതകളും ഉദാഹരണത്തിൽ നിന്ന് നീക്കം ചെയ്യാൻ തുടങ്ങി. ചില ഘട്ടങ്ങളിൽ, എനിക്ക് അവരുടെ കോഡ് പൂർണ്ണമായും വലിച്ചെറിയാനും സ്വന്തമായി എഴുതാനും കഴിയുമെന്ന് ഞാൻ മനസ്സിലാക്കി - ഇത് അതേ പ്രശ്നം പ്രകടമാക്കുന്നു - നിർമ്മാണത്തിൽ ഇത് 3-4 മടങ്ങ് മന്ദഗതിയിലാണ് പ്രവർത്തിക്കുന്നത്:

create function dbo.isPrime (@n bigint)
returns int
as
  begin
  if @n = 1 return 0
  if @n = 2 return 1
  if @n = 3 return 1
  if @n % 2 = 0 return 0
  declare @sq int
  set @sq = sqrt(@n)+1 -- check odds up to sqrt
  declare @dv int = 1
  while @dv < @sq 
    begin
	set @dv=@dv+2
	if @n % @dv = 0 return 0
	end
  return 1
  end
GO
declare @dt datetime set @dt=getdate()
select dbo.isPrime(1000000000000037)
select datediff(ms,@dt,getdate()) as ms
GO

എല്ലാം ശരിയാണെങ്കിൽ, ഒരു സംഖ്യയുടെ പ്രാഥമികത പരിശോധിക്കുന്നതിന് 6-7-8 സെക്കൻഡ് എടുക്കും. ഇത് നിരവധി സെർവറുകളിൽ സംഭവിച്ചു. എന്നാൽ ചിലതിൽ, പരിശോധന 25-40 സെക്കൻഡ് എടുത്തു. രസകരമെന്നു പറയട്ടെ, എക്സിക്യൂഷൻ 14 സെക്കൻഡ് എടുക്കുന്ന സെർവറുകൾ ഇല്ലായിരുന്നു - കോഡ് വളരെ വേഗത്തിലോ വളരെ സാവധാനത്തിലോ പ്രവർത്തിച്ചു, അതായത്, പ്രശ്നം കറുപ്പും വെളുപ്പും ആണെന്ന് പറയാം.

ഞാൻ എന്താണ് ചെയ്തത്? വിഎംവെയർ മെട്രിക്‌സ് ഉപയോഗിച്ചു. അവിടെ എല്ലാം ശരിയാണ് - ധാരാളം വിഭവങ്ങൾ ഉണ്ടായിരുന്നു, റെഡി ടൈം = 0, എല്ലാം മതിയായിരുന്നു, വേഗതയേറിയതും വേഗത കുറഞ്ഞതുമായ സെർവറുകളിൽ സിപിയു = 100 ഒരു വിസിപിയുവിലെ ടെസ്റ്റ് സമയത്ത്. പൈ എന്ന നമ്പർ കണക്കാക്കാൻ ഞാൻ ഒരു ടെസ്റ്റ് നടത്തി - ടെസ്റ്റ് ഏത് സെർവറിലും സമാന ഫലങ്ങൾ കാണിച്ചു. ബ്ലാക്ക് മാജിക്കിന്റെ ഗന്ധം കൂടുതൽ ശക്തമായി.

DEV ഫാമിൽ എത്തിയപ്പോൾ ഞാൻ സെർവറുകളുമായി കളിക്കാൻ തുടങ്ങി. ഹോസ്റ്റിൽ നിന്ന് ഹോസ്റ്റിലേക്കുള്ള vMotion ഒരു സെർവറിനെ "സുഖപ്പെടുത്താൻ" കഴിയുമെന്ന് ഇത് മാറി, എന്നാൽ ഇതിന് "വേഗതയുള്ള" സെർവറിനെ "സ്ലോ" ആക്കി മാറ്റാനും കഴിയും. ഇത് പോലെ തോന്നുന്നു - ചില ഹോസ്റ്റുകൾക്ക് ഒരു പ്രശ്നമുണ്ട്... പക്ഷേ... ഇല്ല. ചില വെർച്വൽ മെഷീൻ ഹോസ്റ്റിൽ മന്ദഗതിയിലായിരുന്നു, എ പറയുക, പക്ഷേ ഹോസ്റ്റ് ബിയിൽ വേഗത്തിൽ പ്രവർത്തിച്ചു. മറ്റൊരു വെർച്വൽ മെഷീൻ, നേരെമറിച്ച്, എയിൽ വേഗത്തിൽ പ്രവർത്തിക്കുകയും ബിയിൽ വേഗത കുറയ്ക്കുകയും ചെയ്തു! "വേഗത", "സ്ലോ" എന്നീ യന്ത്രങ്ങൾ പലപ്പോഴും ഹോസ്റ്റിൽ കറങ്ങിക്കൊണ്ടിരിക്കുന്നു!

ആ നിമിഷം മുതൽ, വായുവിൽ സൾഫറിന്റെ ഒരു പ്രത്യേക മണം ഉണ്ടായിരുന്നു. എല്ലാത്തിനുമുപരി, പ്രശ്നം വെർച്വൽ മെഷീനിലേക്ക് ആട്രിബ്യൂട്ട് ചെയ്യാൻ കഴിയില്ല (ഉദാഹരണത്തിന്, വിൻഡോസ് പാച്ചുകൾ) - എല്ലാത്തിനുമുപരി, ഇത് vMotion ഉപയോഗിച്ച് “വേഗത” ആയി മാറി. എന്നാൽ പ്രശ്നം ഹോസ്റ്റിന് ആട്രിബ്യൂട്ട് ചെയ്യാൻ കഴിയില്ല - എല്ലാത്തിനുമുപരി, ഇതിന് “വേഗത”, “സ്ലോ” മെഷീനുകൾ ഉണ്ടായിരിക്കാം. കൂടാതെ, ഇത് ലോഡുമായി ബന്ധപ്പെട്ടതല്ല - ഹോസ്റ്റിൽ ഒരു “സ്ലോ” മെഷീൻ നേടാൻ എനിക്ക് കഴിഞ്ഞു, അവിടെ അതിനപ്പുറം ഒന്നുമില്ല.

നിരാശ കാരണം, ഞാൻ Syinternals-ൽ നിന്ന് Process Explorer സമാരംഭിക്കുകയും SQL സ്റ്റാക്ക് നോക്കുകയും ചെയ്തു. വേഗത കുറഞ്ഞ മെഷീനുകളിൽ ലൈൻ പെട്ടെന്ന് എന്റെ കണ്ണിൽ പെട്ടു:

ntoskrnl.exe!KeSynchronizeExecution+0x5bf6
ntoskrnl.exe!KeWaitForMultipleObjects+0x109d
ntoskrnl.exe!KeWaitForMultipleObjects+0xb3f
ntoskrnl.exe!KeWaitForSingleObject+0x377
ntoskrnl.exe!KeQuerySystemTimePrecise+0x881 < — !!!
ntoskrnl.exe!ObDereferenceObjectDeferDelete+0x28a
ntoskrnl.exe!KeSynchronizeExecution+0x2de2
sqllang.dll!CDiagThreadSafe::PxlvlReplace+0x1a20
... ഒഴിവാക്കി
sqldk.dll!SystemThread::MakeMiniSOSTthread+0xa54
KERNEL32.DLL!BaseThreadInitThunk+0x14
ntdll.dll!RtlUserThreadStart+0x21

ഇത് ഇതിനകം എന്തെങ്കിലും ആയിരുന്നു. പ്രോഗ്രാം എഴുതിയത്:

    class Program
    {
        [DllImport("kernel32.dll")]
        static extern void GetSystemTimePreciseAsFileTime(out FILE_TIME lpSystemTimeAsFileTime);

        [StructLayout(LayoutKind.Sequential)]
        struct FILE_TIME
        {
            public int ftTimeLow;
            public int ftTimeHigh;
        }

        static void Main(string[] args)
        {
            for (int i = 0; i < 16; i++)
            {
                int counter = 0;

                var stopwatch = Stopwatch.StartNew();

                while (stopwatch.ElapsedMilliseconds < 1000)
                {
                    GetSystemTimePreciseAsFileTime(out var fileTime);
                    counter++;
                }

                if (i > 0)
                {
                    Console.WriteLine("{0}", counter);
                }
            }
        }
    }

ഈ പ്രോഗ്രാം കൂടുതൽ വ്യക്തമായ മാന്ദ്യം പ്രകടമാക്കി - “ഫാസ്റ്റ്” മെഷീനുകളിൽ ഇത് സെക്കൻഡിൽ 16-18 ദശലക്ഷം സൈക്കിളുകൾ കാണിക്കുന്നു, അതേസമയം വേഗത കുറഞ്ഞ മെഷീനുകളിൽ ഇത് ഒന്നര ദശലക്ഷം അല്ലെങ്കിൽ 700 ആയിരം കാണിക്കുന്നു. അതായത്, വ്യത്യാസം 10-20 മടങ്ങ് (!!!). ഇത് ഇതിനകം തന്നെ ഒരു ചെറിയ വിജയമായിരുന്നു: എന്തായാലും, മൈക്രോസോഫ്റ്റിന്റെയും വിഎംവെയറിന്റെയും പിന്തുണയ്ക്കിടയിൽ കുടുങ്ങിപ്പോകുമെന്ന ഭീഷണി ഉണ്ടായിരുന്നില്ല, അങ്ങനെ അവ പരസ്പരം അമ്പടയാളങ്ങൾ തിരിക്കും.

തുടർന്ന് പുരോഗതി നിലച്ചു - അവധിക്കാലം, പ്രധാനപ്പെട്ട കാര്യങ്ങൾ, വൈറൽ ഹിസ്റ്റീരിയ, ജോലിഭാരത്തിൽ കുത്തനെ വർദ്ധനവ്. ഞാൻ പലപ്പോഴും എന്റെ സഹപ്രവർത്തകരോട് മാന്ത്രിക പ്രശ്നം പരാമർശിക്കാറുണ്ട്, പക്ഷേ ചിലപ്പോൾ അവർ എന്നെ വിശ്വസിക്കുന്നില്ലെന്ന് തോന്നുന്നു - വിഎംവെയർ കോഡ് 10-20 മടങ്ങ് മന്ദഗതിയിലാക്കുന്നു എന്ന പ്രസ്താവന വളരെ ഭയാനകമായിരുന്നു.

എന്താണ് എന്നെ മന്ദഗതിയിലാക്കുന്നതെന്ന് ഞാൻ സ്വയം കുഴിക്കാൻ ശ്രമിച്ചു. ചില സമയങ്ങളിൽ ഞാൻ ഒരു പരിഹാരം കണ്ടെത്തിയതായി എനിക്ക് തോന്നി - ഹോട്ട് പ്ലഗുകൾ ഓണാക്കുന്നതും ഓഫാക്കുന്നതും, മെമ്മറിയുടെ അളവോ പ്രോസസ്സറുകളുടെ എണ്ണമോ മാറ്റുന്നത് പലപ്പോഴും മെഷീനെ “വേഗത” ആക്കി മാറ്റി. എന്നാൽ എന്നേക്കും അല്ല. പക്ഷേ, പുറത്തുപോയി ചക്രത്തിൽ തട്ടിയാൽ മതിയെന്നതാണ് സത്യമായി മാറിയത് - അതായത്, മാറ്റം ഏതെങ്കിലും വെർച്വൽ മെഷീൻ പാരാമീറ്റർ

ഒടുവിൽ, എന്റെ അമേരിക്കൻ സഹപ്രവർത്തകർ പെട്ടെന്ന് മൂലകാരണം കണ്ടെത്തി.

ആതിഥേയരുടെ ആവൃത്തിയിൽ വ്യത്യാസമുണ്ട്!

• ചട്ടം പോലെ, ഇത് ഒരു വലിയ കാര്യമല്ല. പക്ഷേ: ഒരു 'നേറ്റീവ്' ഹോസ്റ്റിൽ നിന്ന് 'വ്യത്യസ്‌ത' ആവൃത്തിയുള്ള ഹോസ്റ്റിലേക്ക് മാറുമ്പോൾ, VMware GetTimePrecise ഫലം ക്രമീകരിക്കണം.
• ചട്ടം പോലെ, SQL സെർവർ പോലെ സെക്കന്റിൽ ദശലക്ഷക്കണക്കിന് തവണ കൃത്യമായ സമയം അഭ്യർത്ഥിക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ ഇല്ലെങ്കിൽ ഇത് ഒരു പ്രശ്നമല്ല.
• എന്നാൽ ഇത് ഭയാനകമല്ല, കാരണം SQL സെർവർ എല്ലായ്പ്പോഴും ഇത് ചെയ്യില്ല (ഉപസംഹാരം കാണുക)

എന്നാൽ ഈ റേക്ക് ശക്തമായി അടിക്കുമ്പോൾ കേസുകളുണ്ട്. എന്നിട്ടും, അതെ, വീലിൽ ടാപ്പുചെയ്യുന്നതിലൂടെ (വിഎം ക്രമീകരണങ്ങളിൽ എന്തെങ്കിലും മാറ്റുന്നതിലൂടെ) കോൺഫിഗറേഷൻ 'വീണ്ടും കണക്കാക്കാൻ' ഞാൻ വിഎംവെയറിനെ നിർബന്ധിച്ചു, നിലവിലെ ഹോസ്റ്റിന്റെ ആവൃത്തി മെഷീന്റെ 'നേറ്റീവ്' ആവൃത്തിയായി മാറി.

തീരുമാനം

www.vmware.com/files/pdf/techpaper/Timekeeping-In-VirtualMachines.pdf

നിങ്ങൾ ടിഎസ്‌സിയുടെ വിർച്ച്വലൈസേഷൻ പ്രവർത്തനരഹിതമാക്കുമ്പോൾ, വിർച്വൽ മെഷീനിൽ നിന്ന് ടിഎസ്‌സി വായിക്കുന്നത് ഫിസിക്കൽ മെഷീന്റെ ടിഎസ്‌സി മൂല്യം നൽകുന്നു, കൂടാതെ വിർച്വൽ മെഷീനിൽ നിന്ന് ടിഎസ്‌സി എഴുതുന്നത് ഫലമുണ്ടാക്കില്ല. മറ്റൊരു ഹോസ്റ്റിലേക്ക് വെർച്വൽ മെഷീൻ മൈഗ്രേറ്റ് ചെയ്യുന്നതോ, സസ്പെൻഡ് ചെയ്ത അവസ്ഥയിൽ നിന്ന് പുനരാരംഭിക്കുന്നതോ, അല്ലെങ്കിൽ ഒരു സ്നാപ്പ്ഷോട്ടിലേക്ക് പുനഃസ്ഥാപിക്കുന്നതോ, TSC തുടർച്ചയായി കുതിക്കാൻ ഇടയാക്കുന്നു. ടിഎസ്‌സി വിർച്ച്വലൈസേഷൻ പ്രവർത്തനരഹിതമാക്കുമ്പോൾ ചില ഗസ്റ്റ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ബൂട്ട് ചെയ്യുന്നതിൽ പരാജയപ്പെടുകയോ അല്ലെങ്കിൽ മറ്റ് ടൈം കീപ്പിംഗ് പ്രശ്നങ്ങൾ കാണിക്കുകയോ ചെയ്യുന്നു. മുൻകാലങ്ങളിൽ, TSC പതിവായി വായിക്കുന്ന ആപ്ലിക്കേഷനുകളുടെ പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിന് ഈ സവിശേഷത ചിലപ്പോൾ ശുപാർശ ചെയ്യപ്പെട്ടിട്ടുണ്ട്, എന്നാൽ വെർച്വൽ TSC യുടെ പ്രകടനം നിലവിലെ ഉൽപ്പന്നങ്ങളിൽ ഗണ്യമായി മെച്ചപ്പെടുത്തിയിട്ടുണ്ട്. വെർച്വൽ മെഷീനിൽ തത്സമയത്തിന്റെ കൃത്യമായ ഉറവിടം ആവശ്യമായ അളവുകൾ നടത്തുമ്പോൾ ഉപയോഗിക്കാനും ഈ സവിശേഷത ശുപാർശ ചെയ്തിട്ടുണ്ട്.

ചുരുക്കത്തിൽ, നിങ്ങൾ പാരാമീറ്റർ ചേർക്കേണ്ടതുണ്ട്

monitor_control.virtual_rdtsc = തെറ്റ്

തീരുമാനം

നിങ്ങൾക്ക് ഒരു ചോദ്യമുണ്ടാകാം: എന്തുകൊണ്ടാണ് SQL പലപ്പോഴും GetTimePrecise എന്ന് വിളിക്കുന്നത്?

എന്റെ പക്കൽ SQL സെർവർ സോഴ്‌സ് കോഡ് ഇല്ല, എന്നാൽ ലോജിക് ഇത് പറയുന്നു. എസ്‌ക്യുഎൽ മിക്കവാറും സഹകരണ കൺകറൻസിയുള്ള ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണ്, അവിടെ ഓരോ ത്രെഡും കാലാകാലങ്ങളിൽ "നൽകണം". ഇത് ചെയ്യാൻ ഏറ്റവും നല്ല സ്ഥലം എവിടെയാണ്? സ്വാഭാവിക കാത്തിരിപ്പ് ഉള്ളിടത്ത് - ലോക്ക് അല്ലെങ്കിൽ ഐ.ഒ. ശരി, പക്ഷേ നമ്മൾ കമ്പ്യൂട്ടേഷണൽ ലൂപ്പുകൾ സ്പിന്നിംഗ് ചെയ്യുകയാണെങ്കിലോ? അപ്പോൾ വ്യക്തവും ഏതാണ്ട് ഒരേയൊരു സ്ഥലം വ്യാഖ്യാതാവിലാണ് (ഇത് യഥാർത്ഥത്തിൽ ഒരു വ്യാഖ്യാതാവല്ല), അടുത്ത പ്രസ്താവന നടപ്പിലാക്കിയ ശേഷം.

സാധാരണയായി, ശുദ്ധമായ കമ്പ്യൂട്ടിംഗ് നെയിലിംഗിനായി SQL സെർവർ ഉപയോഗിക്കാറില്ല, ഇത് ഒരു പ്രശ്നമല്ല. എന്നാൽ എല്ലാത്തരം താൽക്കാലിക ടേബിളുകളിലും പ്രവർത്തിക്കുന്ന ലൂപ്പുകൾ (അത് ഉടനടി കാഷെ ചെയ്യപ്പെടും) കോഡ് വളരെ വേഗത്തിൽ നടപ്പിലാക്കുന്ന പ്രസ്താവനകളുടെ ഒരു ശ്രേണിയിലേക്ക് മാറ്റുന്നു.

വഴിയിൽ, നിങ്ങൾ ഫംഗ്‌ഷൻ നേറ്റീവ് ആയി കംപൈൽ ചെയ്‌താൽ, അത് സമയം ചോദിക്കുന്നത് നിർത്തുന്നു, അതിന്റെ വേഗത 10 മടങ്ങ് വർദ്ധിക്കുന്നു. സഹകരണ മൾട്ടിടാസ്‌കിംഗിന്റെ കാര്യമോ? എന്നാൽ നേറ്റീവ് ആയി കംപൈൽ ചെയ്ത കോഡിന് ഞങ്ങൾ SQL-ൽ പ്രീഎംപ്റ്റീവ് മൾട്ടിടാസ്കിംഗ് ചെയ്യേണ്ടതുണ്ട്.

അവലംബം: www.habr.com