რამდენი გვერდის სივრცეა გამოყენებული პროცესორისთვის. რა არის მყარი დისკის ქეში მეხსიერება და რისთვის არის ის? ქეშის არქიტექტურები და პრინციპები
ქეში - მეხსიერება (ქეში, ნაღდი ფული, ბუფერი- ინგლ.) - გამოიყენება ციფრულ მოწყობილობებში, როგორც მაღალსიჩქარიანი ბუფერში. ქეში მეხსიერება შეიძლება მოიძებნოს კომპიუტერულ მოწყობილობებზე, როგორიცაა პროცესორები, ქსელის ბარათები, CD დისკები და მრავალი სხვა.
ქეშის მუშაობის პრინციპი და არქიტექტურა შეიძლება მნიშვნელოვნად განსხვავდებოდეს.
მაგალითად, ქეში შეიძლება იყოს რეგულარული ბუფერში . მოწყობილობა ამუშავებს მონაცემებს და გადასცემს მათ მაღალსიჩქარიან ბუფერში, სადაც კონტროლერი გადასცემს მონაცემებს ინტერფეისში. ასეთი ქეში შექმნილია შეცდომების თავიდან ასაცილებლად, ტექნიკის მონაცემების მთლიანობის შესამოწმებლად ან მოწყობილობიდან სიგნალის დაშიფვრისთვის ინტერფეისისთვის გასაგებ სიგნალად, შეფერხებების გარეშე. ეს სისტემა გამოიყენება, მაგალითად, ქ CD/DVD CD დისკები.
სხვა შემთხვევაში, ქეში შეიძლება ემსახურებოდეს ხშირად გამოყენებული კოდის შენახვა და ამით აჩქარებს მონაცემთა დამუშავებას. ანუ, მოწყობილობას არ სჭირდება მონაცემების ხელახლა გამოთვლა ან ძებნა, რასაც გაცილებით მეტი დრო დასჭირდება, ვიდრე მისი ქეშიდან წაკითხვა. ამ შემთხვევაში, ქეშის ზომა და სიჩქარე ძალიან მნიშვნელოვან როლს ასრულებს.
ეს არქიტექტურა ყველაზე ხშირად გვხვდება მყარ დისკებზე და ცენტრალურ დამუშავების ერთეულებზე ( პროცესორი).
როდესაც მოწყობილობები მუშაობენ, სპეციალური firmware ან დისპეჩერის პროგრამები შეიძლება ჩაიტვირთოს ქეშში, რომელიც უფრო ნელა იმუშავებს რომი(მხოლოდ წაკითხვადი მეხსიერება).
თანამედროვე მოწყობილობების უმეტესობა იყენებს შერეული ქეშის ტიპი , რომელიც შეიძლება ემსახურებოდეს როგორც ბუფერს, ასევე ხშირად გამოყენებული კოდის შენახვას.
პროცესორებისა და ვიდეო ჩიპების ქეშისთვის დანერგილია რამდენიმე ძალიან მნიშვნელოვანი ფუნქცია.
აღსრულების ერთეულების შერწყმა . ცენტრალური დამუშავების ერთეულები და ვიდეო პროცესორები ხშირად იყენებენ სწრაფ გაზიარებულ ქეშს ბირთვებს შორის. შესაბამისად, თუ ერთ ბირთვს აქვს დამუშავებული ინფორმაცია და ის არის ქეშში და მიიღება ბრძანება იმავე ოპერაციისთვის, ან ამ მონაცემებთან მუშაობისთვის, მაშინ მონაცემები კვლავ არ დამუშავდება პროცესორის მიერ, არამედ იქნება აღებული. ქეში შემდგომი დამუშავებისთვის. ბირთვი ჩამოიტვირთება სხვა მონაცემების დასამუშავებლად. ეს მნიშვნელოვნად ზრდის მუშაობას მსგავს, მაგრამ რთულ გამოთვლებში, განსაკუთრებით თუ ქეში დიდი და სწრაფია.
გაზიარებული ქეში, ასევე საშუალებას აძლევს ბირთვებს უშუალოდ იმუშაონ მასთან, ნელი გვერდის ავლით.
ქეში ინსტრუქციებისთვის. არსებობს ან გაზიარებული, ძალიან სწრაფი L1 ქეში ინსტრუქციებისა და სხვა ოპერაციებისთვის, ან მათთვის გამოყოფილი ქეში. რაც უფრო მეტი ინსტრუქცია ინახება პროცესორში, მით უფრო დიდია ინსტრუქციის ქეში საჭირო. ეს ამცირებს მეხსიერების დაყოვნებას და საშუალებას აძლევს ინსტრუქციების ბლოკს თითქმის დამოუკიდებლად ფუნქციონირებდეს, როდესაც ის სავსეა, ინსტრუქციის ბლოკი პერიოდულად იწყებს უმოქმედობას, რაც ანელებს გამოთვლის სიჩქარეს.
სხვა ფუნქციები და მახასიათებლები.
აღსანიშნავია, რომ ქ პროცესორი(ცენტრალური გადამამუშავებელი ერთეული), გამოიყენება აპარატურის შეცდომის კორექტირება (ECC), რადგან ქეშში მცირე შეცდომამ შეიძლება გამოიწვიოს ერთი უწყვეტი შეცდომა ამ მონაცემების შემდგომი დამუშავებისას.
IN პროცესორიდა GPUარსებობს ქეშის იერარქია , რომელიც საშუალებას გაძლევთ გამოყოთ მონაცემები ცალკეული და ზოგადი ბირთვებისთვის. მიუხედავად იმისა, რომ თითქმის ყველა მონაცემი მეორე დონის ქეშიდან კვლავ კოპირებულია მესამე, ზოგად დონეზე, მაგრამ არა ყოველთვის. პირველი ქეშის დონე ყველაზე სწრაფია და ყოველი მომდევნო უფრო ნელია, მაგრამ უფრო დიდი ზომით.
პროცესორებისთვის ეს ნორმად ითვლება სამიდა ნაკლები ქეში დონე. ეს საშუალებას გაძლევთ დააბალანსოთ სიჩქარე, ქეშის ზომა და სითბოს გაფრქვევა. ვიდეო პროცესორებში ძნელია ორზე მეტი ქეში დონის პოვნა.
ქეშის ზომა, შესრულებაზე გავლენა და სხვა მახასიათებლები.
ბუნებრივია, რაც უფრო დიდია ქეში, უფრო მეტი მონაცემების შენახვა და დამუშავება მას შეუძლია, მაგრამ სერიოზული პრობლემაა.
დიდი ქეში- ეს დიდი ბიუჯეტი. სერვერის პროცესორებში ( პროცესორი), ქეშის გამოყენება შესაძლებელია მდე 80% ტრანზისტორი ბიუჯეტი. ჯერ ერთი, ეს გავლენას ახდენს საბოლოო ღირებულებაზე და მეორეც, იზრდება ენერგიის მოხმარება და სითბოს გაფრქვევა, რაც არ არის შედარებული რამდენიმე პროცენტით გაზრდილ პროდუქტიულობასთან.
ერთ-ერთი მნიშვნელოვანი ფაქტორი, რომელიც ზრდის პროცესორის მუშაობას, არის ქეში მეხსიერების არსებობა, უფრო სწორად მისი მოცულობა, წვდომის სიჩქარე და განაწილება დონეებს შორის.
უკვე საკმაოდ დიდი ხანია, თითქმის ყველა პროცესორი აღჭურვილია ამ ტიპის მეხსიერებით, რაც კიდევ ერთხელ ადასტურებს მისი არსებობის სარგებლიანობას. ამ სტატიაში ვისაუბრებთ ქეში მეხსიერების სტრუქტურაზე, დონეებსა და პრაქტიკულ დანიშნულებაზე, რაც ძალიან მნიშვნელოვანია. პროცესორის მახასიათებლები.
რა არის ქეში მეხსიერება და მისი სტრუქტურა
ქეში მეხსიერება არის ულტრა სწრაფი მეხსიერება, რომელსაც იყენებს პროცესორი მონაცემთა დროებით შესანახად, რომლებზეც ყველაზე ხშირად წვდომა ხდება. ასე შეგვიძლია მოკლედ აღვწეროთ ამ ტიპის მეხსიერება.
ქეში მეხსიერება აგებულია ფლიპ-ფლოპებზე, რომლებიც, თავის მხრივ, შედგება ტრანზისტორებისგან. ტრანზისტორების ჯგუფი გაცილებით მეტ ადგილს იკავებს, ვიდრე იგივე კონდენსატორები, რომლებიც ქმნიან ოპერატიული მეხსიერება. ეს იწვევს წარმოების ბევრ სირთულეს, ასევე მოცულობის შეზღუდვას. სწორედ ამიტომ, ქეში მეხსიერება არის ძალიან ძვირი მეხსიერება, ხოლო აქვს უმნიშვნელო მოცულობები. მაგრამ ამ სტრუქტურიდან მოდის ასეთი მეხსიერების მთავარი უპირატესობა - სიჩქარე. ვინაიდან ფლიპ-ფლოპებს რეგენერაცია არ სჭირდებათ და კარიბჭის დაყოვნების დრო, რომელზეც ისინი იკრიბებიან, მცირეა, ფლიპ-ფლოპის ერთი მდგომარეობიდან მეორეში გადართვის დრო ძალიან სწრაფად ხდება. ეს საშუალებას აძლევს ქეშ მეხსიერებას იმუშაოს იმავე სიხშირეზე, როგორც თანამედროვე პროცესორები.
ასევე, მნიშვნელოვანი ფაქტორია ქეში მეხსიერების განთავსება. ის განლაგებულია თავად პროცესორის ჩიპზე, რაც მნიშვნელოვნად ამცირებს წვდომის დროს. ადრე, ზოგიერთი დონის ქეში მეხსიერება განლაგებული იყო პროცესორის ჩიპის გარეთ, სპეციალურ SRAM ჩიპზე, სადმე დედაპლატზე. ახლა თითქმის ყველა პროცესორს აქვს ქეში მეხსიერება, რომელიც მდებარეობს პროცესორის ჩიპზე.
რისთვის გამოიყენება პროცესორის ქეში?
როგორც ზემოთ აღვნიშნეთ, ქეში მეხსიერების მთავარი დანიშნულებაა პროცესორის მიერ ხშირად გამოყენებული მონაცემების შენახვა. ქეში არის ბუფერი, რომელშიც მონაცემები იტვირთება და მიუხედავად მისი მცირე ზომისა (დაახლოებით 4-16 მბ) თანამედროვე პროცესორები, ის იძლევა მნიშვნელოვან შესრულებას ნებისმიერ აპლიკაციაში.
ქეში მეხსიერების საჭიროების უკეთ გასაგებად, წარმოვიდგინოთ კომპიუტერის მეხსიერების ორგანიზება ოფისის მსგავსად. ოპერატიული მეხსიერება იქნება კაბინეტი საქაღალდეებით, რომლებსაც ბუღალტერი პერიოდულად წვდება მონაცემთა დიდი ბლოკების (ანუ საქაღალდეების) მოსაძიებლად. და ცხრილი იქნება ქეში მეხსიერება.
არის ელემენტები, რომლებიც მოთავსებულია ბუღალტერის სამუშაო მაგიდაზე, რომელსაც იგი რამდენჯერმე მიუთითებს ერთი საათის განმავლობაში. მაგალითად, ეს შეიძლება იყოს ტელეფონის ნომრები, დოკუმენტების რამდენიმე მაგალითი. ამ ტიპის ინფორმაცია განთავსებულია პირდაპირ მაგიდაზე, რაც, თავის მხრივ, ზრდის მათზე წვდომის სიჩქარეს.
ანალოგიურად, მონაცემები შეიძლება დაემატოს იმ დიდი მონაცემთა ბლოკებიდან (საქაღალდეებიდან) ცხრილში სწრაფი გამოყენებისთვის, მაგალითად, დოკუმენტი. როდესაც ეს დოკუმენტი აღარ არის საჭირო, ის კვლავ მოთავსებულია კაბინეტში (RAM-ში), რითაც ასუფთავებს ცხრილს (ქეში მეხსიერება) და ათავისუფლებს ამ ცხრილს ახალი დოკუმენტებისთვის, რომლებიც გამოყენებული იქნება დროის შემდეგ პერიოდში.
ასევე ქეშ მეხსიერების შემთხვევაში, თუ არის რაიმე მონაცემი, რომლის ხელახლა წვდომა შესაძლებელია, მაშინ ეს მონაცემები RAM-დან იტვირთება ქეშ მეხსიერებაში. ძალიან ხშირად, ეს ხდება მონაცემთა ერთობლივი ჩატვირთვით, რომელიც სავარაუდოდ გამოყენებული იქნება მიმდინარე მონაცემების შემდეგ. ანუ, არსებობს ვარაუდები იმის შესახებ, თუ რა იქნება გამოყენებული "შემდეგ". ეს არის კომპლექსური ოპერაციული პრინციპები.
პროცესორის ქეშის დონეები
თანამედროვე პროცესორები აღჭურვილია ქეშით, რომელიც ხშირად შედგება 2 ან 3 დონისგან. რა თქმა უნდა, არის გამონაკლისები, მაგრამ ეს ხშირად ხდება.
ზოგადად, შეიძლება იყოს შემდეგი დონეები: L1 (პირველი დონე), L2 (მეორე დონე), L3 (მესამე დონე). ახლა ცოტა უფრო დეტალურად თითოეულ მათგანზე:
პირველი დონის ქეში (L1)– ყველაზე სწრაფი ქეში მეხსიერების დონე, რომელიც მუშაობს უშუალოდ პროცესორის ბირთვთან, ამ მჭიდრო ურთიერთქმედების წყალობით, ამ დონეს აქვს უმოკლეს წვდომის დრო და მუშაობს პროცესორთან ახლოს სიხშირეებზე. ეს არის ბუფერი პროცესორსა და მეორე დონის ქეშს შორის.
ჩვენ განვიხილავთ ტომებს მაღალი ხარისხის Intel Core i7-3770K პროცესორზე. ეს პროცესორი აღჭურვილია 4x32 KB L1 ქეშით 4 x 32 KB = 128 KB. (32 KB თითო ბირთვზე)
მეორე დონის ქეში (L2)- მეორე დონე უფრო მასშტაბურია, ვიდრე პირველი, მაგრამ, შედეგად, აქვს უფრო დაბალი "სიჩქარის მახასიათებლები". შესაბამისად, ის ემსახურება როგორც ბუფერს L1 და L3 დონეებს შორის. თუ კვლავ გადავხედავთ ჩვენს მაგალითს Core i7-3770 K, მაშინ L2 ქეში მეხსიერების ზომაა 4x256 KB = 1 MB.
მე-3 დონის ქეში (L3)– მესამე დონე ისევ წინა ორზე ნელია. მაგრამ ის მაინც ბევრად უფრო სწრაფია ვიდრე RAM. L3 ქეშის ზომა i7-3770K-ში არის 8 მბ. თუ წინა ორი დონე იზიარებს თითოეულ ბირთვს, მაშინ ეს დონე საერთოა მთელი პროცესორისთვის. მაჩვენებელი საკმაოდ მყარია, მაგრამ არა გადაჭარბებული. ვინაიდან, მაგალითად, ექსტრემალური სერიის პროცესორებისთვის, როგორიცაა i7-3960X, ეს არის 15 მბ, ხოლო ზოგიერთი ახალი Xeon პროცესორისთვის 20-ზე მეტი.
რა არის პროცესორის ქეში?
ქეში არის მეხსიერების ნაწილი, რომელიც უზრუნველყოფს წვდომის მაქსიმალურ სიჩქარეს და აჩქარებს გამოთვლის სიჩქარეს. ის ინახავს იმ მონაცემებს, რომლებსაც პროცესორი ითხოვს ყველაზე ხშირად, ისე რომ პროცესორს არ დასჭირდეს მუდმივი წვდომა სისტემის მეხსიერებაში მათთვის.
მოგეხსენებათ, ეს არის კომპიუტერული ტექნიკის ნაწილი, რომელიც ხასიათდება მონაცემთა გაცვლის ყველაზე ნელი სიჩქარით. თუ პროცესორს სჭირდება გარკვეული ინფორმაცია, ის გადადის RAM-ში მისი ამავე სახელწოდების ავტობუსის მეშვეობით. პროცესორისგან მოთხოვნის მიღების შემდეგ, ის იწყებს თავის ანალებში ჩაღრმავებას პროცესორისთვის საჭირო მონაცემების ძიებაში. მიღებისთანავე, ოპერატიული მეხსიერება უგზავნის მათ პროცესორს იმავე მეხსიერების ავტობუსით. მონაცემთა გაცვლის ეს წრე ყოველთვის ძალიან გრძელი იყო. ამიტომ, მწარმოებლებმა გადაწყვიტეს, რომ მათ შეეძლოთ პროცესორს დაუშვან მონაცემების შენახვა სადმე ახლოს. ქეშის მუშაობის გზა ეფუძნება მარტივ იდეას.
იფიქრეთ მეხსიერებაზე, როგორც სკოლის ბიბლიოთეკაზე. სტუდენტი უახლოვდება თანამშრომელს წიგნს, ის მიდის თაროებზე, ეძებს მას, უბრუნდება სტუდენტს, ამზადებს სათანადოდ და გადადის შემდეგ სტუდენტზე. დღის ბოლოს იგივე ოპერაციას იმეორებს, როცა მას წიგნებს უბრუნებენ. ასე მუშაობს პროცესორი ქეშის გარეშე.
რატომ სჭირდება პროცესორს ქეში?
ახლა წარმოიდგინეთ, რომ ბიბლიოთეკარი დაიღალა გამუდმებით წინ და უკან სირბილით წიგნებით, რომლებსაც მუდმივად ითხოვენ მისგან წლიდან წლამდე, დღითი დღე. მან შეიძინა დიდი კაბინეტი, სადაც ინახავს ყველაზე ხშირად მოთხოვნად წიგნებსა და სახელმძღვანელოებს. დანარჩენები, რომლებიც მოთავსებულია, რა თქმა უნდა, აგრძელებენ შენახვას იმავე თაროებზე. მაგრამ ეს ყოველთვის ხელთ არის. რამდენი დრო დაზოგა ამ კაბინეტით, როგორც თავისთვის, ასევე სხვებისთვის. ეს არის ქეში.
ასე რომ, ქეშს შეუძლია შეინახოს მხოლოდ ყველაზე საჭირო მონაცემები?
დიახ. მაგრამ მას მეტი შეუძლია. მაგალითად, მას შემდეგ რაც უკვე ინახავს ხშირად საჭირო მონაცემებს, მას შეუძლია შეაფასოს (პროცესორის დახმარებით) სიტუაცია და მოითხოვოს საჭირო ინფორმაცია. ასე რომ, ვიდეო გაქირავების მომხმარებელი, რომელმაც მოითხოვა ფილმი "Die Hard" პირველი ნაწილით, დიდი ალბათობით ითხოვს მეორეს. და აი ის! იგივე ეხება პროცესორის ქეშს. RAM-ზე წვდომით და გარკვეული მონაცემების შენახვით, ის ასევე იღებს მონაცემებს მეზობელი მეხსიერების უჯრედებიდან. მონაცემთა ასეთ ნაწილებს ქეშის ხაზებს უწოდებენ.
რა არის ორ დონის ქეში?
თანამედროვე პროცესორს აქვს ორი დონე. შესაბამისად, პირველი და მეორე. ისინი ინიშნებიან ასო L-ით ინგლისური დონიდან. პირველი - L1 - უფრო სწრაფია, მაგრამ მცირე მოცულობით. მეორე - L2 - არის ცოტა უფრო დიდი, მაგრამ ნელი, მაგრამ უფრო სწრაფი ვიდრე RAM. პირველი დონის ქეში იყოფა ინსტრუქციის ქეშად და მონაცემთა ქეშად. ინსტრუქციის ქეში ინახავს ინსტრუქციების ერთობლიობას, რომელიც პროცესორს სჭირდება გამოთვლებისთვის. ვინაიდან მონაცემთა ქეში ინახავს რაოდენობებს ან მნიშვნელობებს, რომლებიც საჭიროა მიმდინარე გაანგარიშებისთვის. ხოლო მეორე დონის ქეში გამოიყენება კომპიუტერის ოპერატიული მეხსიერებიდან მონაცემების ჩასატვირთად. ქეშის დონის მუშაობის პრინციპი ასევე შეიძლება აიხსნას სკოლის ბიბლიოთეკის მაგალითის გამოყენებით. ასე რომ, შეძენილი კაბინეტის შევსების შემდეგ, ბიბლიოთეკარი ხვდება, რომ აღარ არის საკმარისი წიგნები, რისთვისაც მას მუდმივად უწევს დარბაზში სირბილი. მაგრამ ასეთი წიგნების სია დასრულებულია და თქვენ უნდა შეიძინოთ იგივე კაბინეტი. მან არ გადააგდო პირველი - სამწუხაროა - და უბრალოდ იყიდა მეორე. ახლა კი, როცა პირველი ივსება, ბიბლიოთეკარი იწყებს მეორის შევსებას, რომელიც ამოქმედდება, როცა პირველი ივსება, მაგრამ საჭირო წიგნები მასში არ ჯდება. იგივეა ქეშის დონეზე. მიკროპროცესორული ტექნოლოგიების განვითარებასთან ერთად, პროცესორის ქეშის დონე იზრდება ზომაში.
განაგრძობს ქეში ზრდას?
ძლივს. პროცესორის სიხშირის დევნა ასევე დიდხანს არ გაგრძელებულა და მწარმოებლებმა იპოვეს ენერგიის გაზრდის სხვა გზები. იგივე ქეში. კონკრეტულად რომ ვთქვათ, დონეების მოცულობა და რაოდენობა არ შეიძლება უსასრულოდ გაბერილი. ქეში არ უნდა გადაიქცეს RAM-ის მეორე ჯოხად ნელი წვდომის სიჩქარით ან პროცესორის ზომა დედაპლატის ზომით ნახევარამდე შეამციროს. ყოველივე ამის შემდეგ, მონაცემთა წვდომის სიჩქარე, პირველ რიგში, არის ენერგიის მოხმარება და თავად პროცესორის შესრულების ღირებულება. ასევე გახშირდა ქეშის გამოტოვება (განსხვავებით ქეშის დარტყმებისგან), სადაც პროცესორი წვდება ქეშურ მეხსიერებას იმ მონაცემებისთვის, რომლებიც არ არის. ქეშში არსებული მონაცემები მუდმივად განახლდება სხვადასხვა ალგორითმის გამოყენებით, რათა გაზარდოს ქეშის დარტყმის ალბათობა.
წაიკითხეთ: 644
თითქმის ყველა დეველოპერმა იცის, რომ პროცესორის ქეში არის პატარა, მაგრამ სწრაფი მეხსიერება, რომელიც ინახავს მონაცემებს ახლახანს მონახულებული მეხსიერების უბნებიდან - განმარტება არის მოკლე და საკმაოდ ზუსტი. თუმცა, ქეშის მექანიზმების შესახებ მოსაწყენი დეტალების ცოდნა აუცილებელია იმ ფაქტორების გასაგებად, რომლებიც გავლენას ახდენენ კოდის შესრულებაზე.
ამ სტატიაში განვიხილავთ უამრავ მაგალითს, რომლებიც ასახავს ქეშის სხვადასხვა მახასიათებლებს და მათ გავლენას შესრულებაზე. მაგალითები იქნება C#-ში, ენისა და პლატფორმის არჩევანი დიდად არ იმოქმედებს შესრულების შეფასებასა და საბოლოო დასკვნებზე. ბუნებრივია, გონივრულ ფარგლებში, თუ აირჩევთ ენას, რომელშიც მასივიდან მნიშვნელობის წაკითხვა ჰეშის ცხრილზე წვდომის ტოლფასია, ვერ მიიღებთ ინტერპრეტაციად შედეგს. მთარგმნელის შენიშვნები დახრილია.
ჰაბრაკუტი - - -
მაგალითი 1: მეხსიერების წვდომა და შესრულება
როგორ ფიქრობთ, რამდენად სწრაფია მეორე ციკლი პირველზე?int arr = ახალი int;// პირველი
for (int i = 0; i< arr.Length; i++) arr[i] *= 3;// წამი
for (int i = 0; i< arr.Length; i += 16) arr[i] *= 3;
პირველი ციკლი ამრავლებს მასივის ყველა მნიშვნელობას 3-ით, მეორე ციკლი ამრავლებს მხოლოდ ყოველ მეთექვსმეტე მნიშვნელობას. მხოლოდ მეორე ციკლი სრულდება 6% მუშაობსპირველი ციკლი, მაგრამ თანამედროვე მანქანებზე ორივე ციკლი შესრულებულია დაახლოებით თანაბარ დროში: 80 msდა 78 msშესაბამისად (ჩემს აპარატზე).
გამოსავალი მარტივია - მეხსიერების წვდომა. ამ მარყუჟების სიჩქარე პირველ რიგში განისაზღვრება მეხსიერების ქვესისტემის სიჩქარით და არა მთელი რიცხვის გამრავლების სიჩქარით. როგორც შემდეგ მაგალითში დავინახავთ, RAM-ზე წვდომის რაოდენობა ერთნაირია როგორც პირველ, ასევე მეორე შემთხვევაში.
მაგალითი 2: ქეშის ხაზების გავლენა
მოდით ჩავუღრმავდეთ და ვცადოთ სხვა ნაბიჯების მნიშვნელობები, არა მხოლოდ 1 და 16:for (int i = 0; i< arr.Length; i += K /* шаг */ ) arr[i] *= 3;
აქ არის ამ მარყუჟის გაშვების დრო სხვადასხვა ნაბიჯის მნიშვნელობებისთვის K:
გთხოვთ გაითვალისწინოთ, რომ საფეხურის მნიშვნელობებით 1-დან 16-მდე, მუშაობის დრო პრაქტიკულად უცვლელი რჩება. მაგრამ 16-ზე მეტი მნიშვნელობებით, გაშვების დრო დაახლოებით ნახევარით მცირდება ყოველ ჯერზე, როცა ნაბიჯს გავაორმაგებთ. ეს არ ნიშნავს, რომ მარყუჟი როგორღაც ჯადოსნურად იწყებს მუშაობას უფრო სწრაფად, უბრალოდ, გამეორებების რაოდენობაც მცირდება. საკვანძო წერტილი არის იგივე ოპერაციული დრო საფეხურის მნიშვნელობებით 1-დან 16-მდე.
ამის მიზეზი ის არის, რომ თანამედროვე პროცესორებს არ აქვთ წვდომა მეხსიერებაში ერთი ბაიტით, არამედ მცირე ბლოკებში, რომლებსაც ქეშის ხაზები ეწოდება. როგორც წესი, სტრიქონის ზომაა 64 ბაიტი. მეხსიერებიდან რომელიმე მნიშვნელობის წაკითხვისას, მინიმუმ ერთი ქეშის ხაზი ხვდება ქეშში. ამ მწკრივის ნებისმიერ მნიშვნელობაზე შემდგომი წვდომა ძალიან სწრაფია.
იმის გამო, რომ 16 int მნიშვნელობა იკავებს 64 ბაიტს, მარყუჟები 1-დან 16-მდე საფეხურებით წვდებიან იმავე რაოდენობის ქეშის ხაზებს, უფრო ზუსტად, მასივის ყველა ქეშის ხაზს. 32-ე საფეხურზე წვდომა ხდება ყოველ მეორე ხაზზე, 64-ე საფეხურზე, ყოველ მეოთხეზე.
ამის გაგება ძალიან მნიშვნელოვანია ზოგიერთი ოპტიმიზაციის ტექნიკისთვის. მასზე წვდომის რაოდენობა დამოკიდებულია მეხსიერებაში მონაცემთა მდებარეობაზე. მაგალითად, გაუსწორებელ მონაცემებს შეიძლება დასჭირდეს ორი წვდომა მთავარ მეხსიერებაზე ერთის ნაცვლად. როგორც ზემოთ გავარკვიეთ, მუშაობის სიჩქარე ორჯერ ნაკლები იქნება.
მაგალითი 3: 1 და 2 დონის ქეშის ზომები (L1 და L2)
თანამედროვე პროცესორებს, როგორც წესი, აქვთ ორი ან სამი დონის ქეში, რომელსაც ჩვეულებრივ უწოდებენ L1, L2 და L3. სხვადასხვა დონეზე ქეშის ზომის გასარკვევად, შეგიძლიათ გამოიყენოთ CoreInfo პროგრამა ან Windows API ფუნქცია GetLogicalProcessorInfo. ორივე მეთოდი ასევე გვაწვდის ინფორმაციას თითოეული დონის ქეშის ხაზის ზომის შესახებ.ჩემს აპარატზე CoreInfo იტყობინება 32 KB L1 მონაცემთა ქეში, 32 KB L1 ინსტრუქციის ქეშები და 4 MB L2 მონაცემთა ქეშები. თითოეულ ბირთვს აქვს თავისი პირადი L1 ქეში, L2 ქეში იზიარებს თითოეული წყვილი ბირთვით:
ლოგიკური პროცესორი ქეში რუკაზე: *--- მონაცემთა ქეში 0, დონე 1, 32 კბ, ასოცირებული 8, ხაზის ზომა 64 *--- ინსტრუქციის ქეში 0, დონე 1, 32 კბ, Assoc 8, ხაზის ზომა 64 ---- მონაცემთა ქეში 1, დონე 1, 32 KB, Assoc 8, LineSize 64 --*-- Instruction Cache 1, Level 1, 32 KB, Assoc 8, LineSize 64 **-- Unified Cache 0, Level 2, 4 MB, Assoc 16, LineSize 64 --*- მონაცემთა ქეში 2, დონე 1, 32 კბ, ასოცირებული 8, ხაზის ზომა 64 --*- ინსტრუქციის ქეში 2, დონე 1, 32 კბ, ასოცირებული 8, ხაზის ზომა 64 ---* მონაცემთა ქეში 3, დონე 1, 32 KB, Assoc 8, LineSize 64 ---* Instruction Cache 3, Level 1, 32 KB, Assoc 8, LineSize 64 --** Unified Cache 1, Level 2, 4 MB, Assoc 16, LineSize 64
მოდით შევამოწმოთ ეს ინფორმაცია ექსპერიმენტულად. ამისათვის მოდით გავიაროთ ჩვენი მასივი, გავზარდოთ ყოველი მე-16 მნიშვნელობა - მარტივი გზა მონაცემთა შესაცვლელად თითოეულ ქეშის ხაზში. დასასრულს რომ მივაღწევთ, საწყისს ვუბრუნდებით. მოდით შევამოწმოთ მასივის სხვადასხვა ზომა, ჩვენ უნდა დავინახოთ შესრულების ვარდნა, როდესაც მასივი აღარ ჯდება სხვადასხვა დონის ქეშებში.
კოდი არის:
int ნაბიჯები = 64 * 1024 * 1024; // გამეორებების რაოდენობა
int lengthMod = arr.სიგრძე - 1; // მასივის ზომა -- სიმძლავრე ორიfor (int i = 0; i< steps; i++)
{
// x & lengthMod = x % arr.Length, რადგან ორი ძალა
arr[(i * 16) & lengthMod]++;
}
Ტესტის პასუხები:
ჩემს აპარატზე შესამჩნევია შესრულების ვარდნა 32 KB და 4 MB შემდეგ - ეს არის L1 და L2 ქეშის ზომები.
მაგალითი 4: ინსტრუქციის პარალელიზმი
ახლა სხვა რამეს მივხედოთ. თქვენი აზრით, ამ ორი მარყუჟიდან რომელი უფრო სწრაფად შესრულდება?int ნაბიჯები = 256 * 1024 * 1024;
int a = ახალი int;// პირველი
for (int i = 0; i< steps; i++) { a++; a++; }// წამი
for (int i = 0; i< steps; i++) { a++; a++; }
გამოდის, რომ მეორე მარყუჟი თითქმის ორჯერ უფრო სწრაფად მუშაობს, ყოველ შემთხვევაში, ყველა მანქანაზე, რომელიც მე გამოვცადე. რატომ? იმის გამო, რომ მარყუჟების შიგნით ბრძანებებს აქვთ განსხვავებული მონაცემების დამოკიდებულება. პირველ ბრძანებებს აქვთ შემდეგი დამოკიდებულების ჯაჭვი:
მეორე ციკლში დამოკიდებულებებია:
თანამედროვე პროცესორების ფუნქციურ ნაწილებს შეუძლიათ შეასრულონ გარკვეული რაოდენობის გარკვეული ოპერაციები ერთდროულად, როგორც წესი, არც ისე დიდი რაოდენობით. მაგალითად, შესაძლებელია L1 ქეშიდან მონაცემების პარალელური წვდომა ორ მისამართზე, ასევე შესაძლებელია ორი მარტივი არითმეტიკული ინსტრუქციის ერთდროულად შესრულება. პირველ ციკლში პროცესორი ვერ გამოიყენებს ამ შესაძლებლობებს, მაგრამ შეუძლია მეორეში.
მაგალითი 5: ქეში ასოციაციურობა
ერთ-ერთი მთავარი კითხვა, რომელსაც პასუხი უნდა გაეცეს ქეშის შექმნისას, არის თუ არა მეხსიერების გარკვეული რეგიონის მონაცემების შენახვა ნებისმიერ ქეში უჯრედში თუ მხოლოდ ზოგიერთ მათგანში. სამი შესაძლო გამოსავალი:- პირდაპირი რუკების ქეში, RAM-ში თითოეული ქეში ხაზის მონაცემები ინახება მხოლოდ ერთ წინასწარ განსაზღვრულ ქეშის ადგილას. რუკების გამოსათვლელად ყველაზე მარტივი გზაა: row_index_in_memory % number_of_cache_cells. ერთსა და იმავე უჯრედზე დატანილი ორი ხაზი არ შეიძლება იყოს ქეშში ერთდროულად.
- N- შესვლის ნაწილობრივი ასოციაციური ქეში, თითოეული ხაზი შეიძლება ინახებოდეს N სხვადასხვა ქეშის ადგილას. მაგალითად, 16 ჩანაწერის ქეშში, ხაზი შეიძლება ინახებოდეს ჯგუფში შემადგენელი 16 უჯრედიდან ერთ-ერთში. როგორც წესი, რიგები, რომლებსაც აქვთ ინდექსების თანაბარი ნაკლებად მნიშვნელოვანი ბიტები, იზიარებენ ერთ ჯგუფს.
- სრულად ასოციაციური ქეშინებისმიერი ხაზის შენახვა შესაძლებელია ქეშის ნებისმიერ ადგილას. გამოსავალი თავისი ქცევით ჰეშის ცხრილის ექვივალენტურია.
მაგალითად, ჩემს აპარატზე, 4 MB L2 ქეში არის 16 ჩანაწერის ნაწილობრივი ასოციაციური ქეში. მთელი ოპერატიული მეხსიერება დაყოფილია ხაზების ნაკრებებად მათი ინდექსების ყველაზე ნაკლებად მნიშვნელოვანი ბიტების მიხედვით, თითოეული ნაკრებიდან ხაზები კონკურენციას უწევს 16 L2 ქეში უჯრედების ერთ ჯგუფს.
ვინაიდან L2 ქეშს აქვს 65,536 უჯრედი (4 * 2 20 / 64) და თითოეული ჯგუფი შედგება 16 უჯრედისგან, სულ გვაქვს 4,096 ჯგუფი. ამრიგად, მწკრივის ინდექსის ქვედა 12 ბიტი განსაზღვრავს რომელ ჯგუფს ეკუთვნის ეს მწკრივი (2 12 = 4,096). შედეგად, 262,144 (4,096 * 64) მრავლობითი მისამართების რიგები იზიარებენ 16 უჯრედისგან შემდგარ ერთსა და იმავე ჯგუფს და ეჯიბრებიან მასში სივრცისთვის.
ასოციაციურობის ეფექტის მისაღწევად, ჩვენ მუდმივად გვჭირდება წვდომა იმავე ჯგუფის რიგების დიდ რაოდენობაზე, მაგალითად, შემდეგი კოდის გამოყენებით:
საჯარო სტატიკური ხანგრძლივი განახლებაEveryKthByte(ბაიტი arr, int K)
{
const int rep = 1024 * 1024; // გამეორებების რაოდენობაწამზომი sw = წამზომი.StartNew();
int p = 0;
for (int i = 0; i< rep; i++)
{
arr[p]++;P += K; თუ (p >= arr.სიგრძე) p = 0;
}Sw.Stop();
დაბრუნება sw.ElapsedMilliseconds;
}
მეთოდი ზრდის მასივის ყოველ Kth ელემენტს. როცა ბოლომდე მივაღწევთ, თავიდან ვიწყებთ. გამეორებების საკმაოდ დიდი რაოდენობის შემდეგ (2 20), ვჩერდებით. მე გავაკეთე სხვადასხვა ზომის მასივი და K საფეხურის მნიშვნელობები (ლურჯი - ხანგრძლივი გაშვების დრო, თეთრი - მოკლე):
ცისფერი ზონები შეესაბამება იმ შემთხვევებს, როდესაც მონაცემთა მუდმივი ცვლილებებით, ქეში ვერ იტევს ყველა საჭირო მონაცემი ერთდროულად. ნათელი ლურჯი ფერი მიუთითებს მუშაობის დროს დაახლოებით 80 ms, თითქმის თეთრი - 10 ms.
მოდით გავუმკლავდეთ ლურჯ ზონებს:
- რატომ ჩნდება ვერტიკალური ხაზები?ვერტიკალური ხაზები შეესაბამება საფეხურების მნიშვნელობებს, რომლებზეც წვდომა ხდება ძალიან ბევრ მწკრივზე (16-ზე მეტი) ერთი ჯგუფიდან. ამ მნიშვნელობებისთვის, ჩემი აპარატის 16 ჩანაწერიანი ქეში ვერ იტევს ყველა საჭირო მონაცემს.
ზოგიერთი ცუდი ნაბიჯის მნიშვნელობა არის ორი სიმძლავრე: 256 და 512. მაგალითად, განიხილეთ ნაბიჯი 512 და 8 მბ მასივი. ამ ნაბიჯით, მასივში არის 32 სექცია (8 * 2 20 / 262 144), რომლებიც ეჯიბრებიან ერთმანეთს უჯრედებისთვის 512 ქეში ჯგუფში (262 144 / 512). არის 32 სექცია, მაგრამ თითოეული ჯგუფისთვის ქეშში მხოლოდ 16 უჯრედია, ამიტომ ყველასთვის საკმარისი ადგილი არ არის.
სხვა საფეხურის მნიშვნელობები, რომლებიც არ არის ორი ძალა, უბრალოდ უიღბლოა, რაც იწვევს დარტყმების დიდ რაოდენობას იმავე ქეშის ჯგუფებში და ასევე იწვევს ფიგურაში ვერტიკალური ლურჯი ხაზების გამოჩენას. ამ დროს რიცხვთა თეორიის მოყვარულებს ფიქრისთვის ეპატიჟებიან.
- რატომ იშლება ვერტიკალური ხაზები 4 მბ საზღვარზე?როდესაც მასივის ზომა არის 4 მბ ან ნაკლები, 16-შეყვანის ქეში იქცევა სრულად ასოციაციური ქეშივით, ანუ მას შეუძლია მოათავსოს მასივის ყველა მონაცემი კონფლიქტების გარეშე. არ არის 16-ზე მეტი ადგილი, რომელიც იბრძვის ერთი ქეში ჯგუფისთვის (262,144 * 16 = 4 * 2 20 = 4 MB).
- რატომ არის დიდი ლურჯი სამკუთხედი ზედა მარცხენა მხარეს?რადგან მცირე ნაბიჯით და დიდი მასივით, ქეში ვერ ახერხებს ყველა საჭირო მონაცემს. ქეშის ასოციაციურობის ხარისხი აქ მეორეხარისხოვან როლს ასრულებს, შეზღუდვა დაკავშირებულია L2 ქეშის ზომასთან.
მაგალითად, მასივის ზომით 16 მბ და ნაბიჯით 128, ჩვენ ვწვდებით ყოველ 128-ე ბაიტს, რითაც ვცვლით მასივის ყოველ მეორე ქეში ხაზს. ქეშში ყოველი მეორე ხაზის შესანახად გჭირდებათ 8 მბ ქეში, მაგრამ ჩემს აპარატზე არის მხოლოდ 4 მბ.
მაშინაც კი, თუ ქეში მთლიანად ასოციაციური იყო, ის არ დაუშვებს მასში 8 მბ მონაცემების შენახვას. გაითვალისწინეთ, რომ უკვე განხილულ მაგალითში 512 ნაბიჯით და მასივის ზომით 8 მბ, ჩვენ გვჭირდება მხოლოდ 1 მბ ქეში ყველა საჭირო მონაცემის შესანახად, მაგრამ ეს შეუძლებელია ქეშის არასაკმარისი ასოციაციურობის გამო.
- რატომ იძენს სამკუთხედის მარცხენა მხარე თანდათანობით ინტენსივობას?მაქსიმალური ინტენსივობა ხდება 64 ბაიტის საფეხურზე, რაც უდრის ქეშის ხაზის ზომას. როგორც პირველ და მეორე მაგალითებში ვნახეთ, იმავე მწკრივზე თანმიმდევრული წვდომა თითქმის არაფერი ღირს. ვთქვათ, 16 ბაიტის ნაბიჯით, გვაქვს ოთხი მეხსიერების წვდომა ერთის ფასად.
იმის გამო, რომ გამეორებების რაოდენობა ჩვენს ტესტში ერთნაირია ნებისმიერი ნაბიჯის მნიშვნელობისთვის, უფრო იაფი ნაბიჯი იწვევს ნაკლებ დროს.
ქეში ასოციაციურობა არის საინტერესო რამ, რომელიც შეიძლება გამოვლინდეს გარკვეულ პირობებში. ამ სტატიაში განხილული სხვა პრობლემებისგან განსხვავებით, ეს არც ისე სერიოზულია. ეს ნამდვილად არ არის ის, რაც მუდმივ ყურადღებას მოითხოვს პროგრამების წერისას.
მაგალითი 6: ცრუ ქეშის დაყოფა
მრავალბირთვიან მანქანებზე შეიძლება შეგხვდეთ სხვა პრობლემა - ქეშის თანმიმდევრულობა. პროცესორის ბირთვებს აქვთ ნაწილობრივ ან მთლიანად ცალკეული ქეშები. ჩემს აპარატზე, L1 ქეშები ცალკეა (ჩვეულებრივ) და ასევე არის ორი L2 ქეში, რომელსაც იზიარებს თითოეული წყვილი ბირთვი. დეტალები შეიძლება განსხვავდებოდეს, მაგრამ ზოგადად, თანამედროვე მრავალბირთვიან პროცესორებს აქვთ მრავალ დონის იერარქიული ქეში. უფრო მეტიც, ყველაზე სწრაფი, მაგრამ ასევე ყველაზე პატარა ქეშები ეკუთვნის ცალკეულ ბირთვებს.როდესაც ერთი ბირთვი ცვლის მნიშვნელობას თავის ქეშში, სხვა ბირთვები ვეღარ გამოიყენებენ ძველ მნიშვნელობას. სხვა ბირთვების ქეშებში მნიშვნელობა უნდა განახლდეს. უფრო მეტიც, უნდა განახლდეს მთელი ქეში ხაზი, ვინაიდან ქეშები მუშაობენ მონაცემებზე მწკრივის დონეზე.
მოდით ვაჩვენოთ ეს პრობლემა შემდეგი კოდით:
private static int s_counter = new int ;პირადი void UpdateCounter(int პოზიცია)
{
for (int j = 0; j< 100000000; j++)
{
s_counter = s_counter + 3;
}
}
თუ ჩემს ოთხბირთვიან აპარატზე ამ მეთოდს ვუწოდებ პარამეტრებს 0, 1, 2, 3 ერთდროულად ოთხი ძაფიდან, მაშინ მუშაობის დრო იქნება 4.3 წამი. მაგრამ თუ მე გამოვიძახებ მეთოდს 16, 32, 48, 64 პარამეტრებით, მაშინ გაშვების დრო იქნება მხოლოდ 0.28 წამი.
რატომ? პირველ შემთხვევაში, ძაფებით დამუშავებული ოთხივე მნიშვნელობა ნებისმიერ დროს, სავარაუდოდ, ერთ ქეში ხაზში აღმოჩნდება. ყოველ ჯერზე, როდესაც ერთი ბირთვი ზრდის მნიშვნელობას, ის აღნიშნავს ქეში უჯრედებს, რომლებიც შეიცავს ამ მნიშვნელობას სხვა ბირთვებში, როგორც არასწორი. ამ ოპერაციის შემდეგ, ყველა სხვა ბირთვს მოუწევს ხაზის ხელახლა ქეშირება. ეს ხდის ქეშირების მექანიზმს არაფუნქციონირებს, რაც ამცირებს შესრულებას.
მაგალითი 7: აპარატურის სირთულე
ახლაც, როცა ქეშის მუშაობის პრინციპები არ არის თქვენთვის საიდუმლო, აპარატურა მაინც მოგცემთ სიურპრიზებს. პროცესორები ერთმანეთისგან განსხვავდებიან ოპტიმიზაციის მეთოდებით, ევრისტიკით და განხორციელების სხვა დახვეწილობით.ზოგიერთი პროცესორის L1 ქეშს შეუძლია წვდომა ორ უჯრედზე პარალელურად, თუ ისინი განსხვავებულ ჯგუფს მიეკუთვნებიან, მაგრამ თუ ისინი მიეკუთვნებიან იმავე ჯგუფს, მხოლოდ თანმიმდევრულად. რამდენადაც ვიცი, ზოგიერთს შეუძლია პარალელურად ერთი და იგივე უჯრედის სხვადასხვა კვარტალში წვდომა.
პროცესორებმა შეიძლება გაგაოცოთ ჭკვიანი ოპტიმიზაციით. მაგალითად, წინა მაგალითის კოდი ცრუ ქეშის გაზიარების შესახებ არ მუშაობს ჩემს სახლის კომპიუტერზე, როგორც ეს იყო დაგეგმილი - უმარტივეს შემთხვევებში პროცესორს შეუძლია მუშაობის ოპტიმიზაცია და უარყოფითი ეფექტების შემცირება. თუ კოდს ოდნავ შეცვლით, ყველაფერი თავის ადგილზე დგება.
აქ არის კიდევ ერთი მაგალითი ტექნიკის უცნაური უცნაურობების შესახებ:
კერძო სტატიკური int A, B, C, D, E, F, G;პირადი სტატიკური სიცარიელე Weirdness()
{
for (int i = 0; i< 200000000; i++)
{
<какой-то код>
}
}
თუ სამაგიეროდ<какой-то код>შეცვალეთ სამი განსხვავებული ვარიანტი, შეგიძლიათ მიიღოთ შემდეგი შედეგები:
A, B, C, D ველების გაზრდას უფრო მეტი დრო სჭირდება, ვიდრე A, C, E, G ველების გაზრდა. რაც უფრო უცნაურია, რომ A და C ველების გაზრდას A, C ველებზე მეტი დრო სჭირდება. და E, G. ზუსტად არ ვიცი რა არის ამის მიზეზები, მაგრამ შესაძლოა ისინი დაკავშირებულია მეხსიერების ბანკებთან ( დიახ, დიახ, ჩვეულებრივი სამლიტრიანი შემნახველი მეხსიერების ბანკებით და არა ის, რაც თქვენ ფიქრობდით). თუ თქვენ გაქვთ რაიმე აზრი ამ საკითხთან დაკავშირებით, გთხოვთ ისაუბროთ კომენტარებში.
ჩემს აპარატზე, ზემოაღნიშნული არ შეინიშნება, თუმცა, ზოგჯერ არის არანორმალურად ცუდი შედეგები - სავარაუდოდ, დავალების განრიგი აკეთებს საკუთარ "კორექტირებას".
გაკვეთილი, რომელიც ამ მაგალითიდან უნდა ვისწავლოთ, არის ის, რომ ძალიან რთულია ტექნიკის ქცევის სრულად პროგნოზირება. დიახ, შეუძლიაიწინასწარმეტყველეთ ბევრი, მაგრამ თქვენ მუდმივად უნდა დაადასტუროთ თქვენი პროგნოზები გაზომვებისა და ტესტირების გზით.
დასკვნა
ვიმედოვნებ, რომ ყველაფერი, რაც ზემოთ იყო განხილული, დაგეხმარა პროცესორის ქეშის სტრუქტურის გაგებაში. ახლა თქვენ შეგიძლიათ გამოიყენოთ ეს ცოდნა თქვენი კოდის ოპტიმიზაციისთვის.ქეში არის პროცესორში ჩაშენებული მეხსიერება, რომელშიც იწერება RAM-ის ყველაზე ხშირად გამოყენებული მონაცემები (ბრძანებები), რაც მნიშვნელოვნად აჩქარებს მუშაობას.
L1 ქეშის ზომა (8-დან 128 კბ-მდე)
1 დონის ქეშის ზომა.
1 დონის ქეში არის მაღალსიჩქარიანი მეხსიერების ბლოკი, რომელიც მდებარეობს უშუალოდ პროცესორის ბირთვზე.
RAM-დან ამოღებული მონაცემები კოპირებულია მასში.
ძირითადი ინსტრუქციების შენახვა აუმჯობესებს პროცესორის მუშაობას მონაცემთა დამუშავების უფრო სწრაფი სიჩქარის გამო (ქეშიდან დამუშავება უფრო სწრაფია ვიდრე RAM-დან).
პირველი დონის ქეშის მოცულობა მცირეა და შეადგენს კილობაიტებს.
როგორც წესი, "ძველ" პროცესორის მოდელებს აქვთ უფრო დიდი L1 ქეში.
მრავალბირთვიანი მოდელებისთვის, მითითებულია L1 ქეში მეხსიერების რაოდენობა ერთი ბირთვისთვის.
L2 ქეშის ზომა (128-დან 12288 KB-მდე)
მე-2 დონის ქეშის ზომა.
L2 ქეში არის მაღალსიჩქარიანი მეხსიერების ბლოკი, რომელიც ასრულებს იგივე ფუნქციებს, როგორც L1 ქეში (იხ. "L1 ქეშის მოცულობა"), მაგრამ აქვს უფრო დაბალი სიჩქარე და უფრო დიდი ტევადობა.
თუ ირჩევთ პროცესორს რესურსზე ინტენსიური ამოცანებისთვის, მაშინ სასურველი იქნება მოდელი დიდი L2 ქეშით.
მრავალბირთვიანი პროცესორებისთვის მითითებულია მეორე დონის ქეში მეხსიერების მთლიანი რაოდენობა.
L3 ქეშის ზომა (0-დან 16384 KB-მდე)
მე-3 დონის ქეშის ზომა.
ინტეგრირებული L3 ქეში, სწრაფ სისტემურ ავტობუსთან ერთად, ქმნის მონაცემთა გაცვლის მაღალსიჩქარიან არხს სისტემის მეხსიერებით.
როგორც წესი, მხოლოდ CPU-ები სერვერის გადაწყვეტილებებისთვის ან "Desktop" პროცესორების სპეციალური გამოცემებისთვის აღჭურვილია მესამე დონის ქეში მეხსიერებით.
მაგალითად, პროცესორის ხაზებს, როგორიცაა Intel Pentium 4 Extreme Edition, Xeon DP, Itanium 2, Xeon MP და სხვები, აქვთ მესამე დონის ქეში მეხსიერება.
Twin BiCS FLASH - ახალი 3D ფლეშ მეხსიერების ტექნოლოგია
2019 წლის 11 დეკემბერს, IEEE ელექტრონული მოწყობილობების საერთაშორისო შეხვედრაზე (IEDM), TOKYO-Kioxia Corporation-მა გამოაცხადა 3D ფლეშ მეხსიერების ტექნოლოგია - Twin BiCS FLASH.
AMD Radeon Software Adrenalin Edition 2020 დრაივერი 19.12.2 WHQL (დამატებულია)
10 დეკემბერს AMD-მ წარმოადგინა მეგა დრაივერი Radeon Software Adrenalin 2020 Edition 19.12.2 WHQL.
Windows 10 კუმულაციური განახლება 1909 KB4530684
2019 წლის 10 დეკემბერს, Microsoft-მა გამოუშვა კუმულაციური განახლება KB4530684 (Build 18363.535) Windows 10 ნოემბრის 2019 განახლებისთვის (ვერსია 1909) x86, x64 (amd64), ARM64 და Windows Server 2019) დამუშავებული სისტემებისთვის (1909 x4).
NVIDIA Game Ready GeForce 441.66 WHQL დრაივერი
NVIDIA GeForce Game Ready 441.66 WHQL დრაივერი მოიცავს MechWarrior 5: Mercenaries და Detroit: Become Human მხარდაჭერას და ასევე ამატებს G-SYNC მხარდაჭერას MSI MAG251RX და ViewSonic XG270 მონიტორებისთვის.
