Bellek depoları için en iyi uygulamalar

Bu uygulamaları geçici verileri düzenlemek, yükü dağıtmak ve bellek deposu sorunlarına yanıt vermek için kullanın.

Veri yapısı türüne bağlı olarak, MemoryStoreService bellek ve bir veri yapısındaki öğe sayısı üzerinde sınırlamalar uygular. Tüm veri yapıları ayrıca küresel bir bölüm başına istek sınırı ile kısıtlanmıştır.

Anahtarları ve veri yapılarını tasarlayın

Anahtarları ve önekleri statik kullanın bölümüne bakın Veri depoları için en iyi uygulamalar. Bu desenleri hem anahtarlara hem de veri yapısı adlarına uygulayın, böylece her sunucu aynı mantıksal veriyi aynı konuma yönlendirir.

Verilerin ne kadar süreyle yararlı kalacağına uygun sonlandırma süreleri seçin. Kalıcı oyuncu kayıtları veya sonlandırma süresini aşması gereken veriler için bellek depolarını kullanmayın. Hizmetler arasında seçim yaparken yardım için Veri depoları ile bellek depoları bölümüne bakın.

İstek hatalarını yönetin

Geçici hataları yeniden deneyin bölümüne bakın Veri depoları için en iyi uygulamalar.

SetAsync yerine UpdateAsync'ı tercih edin

SetAsync yerine UpdateAsync'ı tercih edin bölümüne bakın Veri depoları için en iyi uygulamalar. Hash haritaları ve sıralı haritalar bu desen için MemoryStoreHashMap:UpdateAsync() ve MemoryStoreSortedMap:UpdateAsync() sağlar.

Tekrarlayan istekleri sıraya koyun

Tekrarlayan istekleri sıraya koyun bölümüne bakın Veri depoları için en iyi uygulamalar.

Kullanımı izleyin

Kullanım Gözlemlenebilirlik Gösterge Tablosu ile kota kullanımını, istek hacmini ve yanıt durumlarını izleyin. Yerleşik e-posta uyarılarını gözden geçirin, önemli bellek deposu metrikleri için özel uyarılar yapılandırın ve hataları araştırmak için Hata Raporu kullanın.

Kapasiteyi artırmadan önce istekleri, öğe boyutlarını ve sonlandırma sürelerini azaltın. Geçerli kullanım varsayılan kotaları aşıyorsa, Genişletilmiş Hizmetler bölümünü değerlendirin.

Sıralı harita ve kuyruk sınırlarını yönetin

Sıralı haritalar ve kuyruklar, maksimum öğe sayısı ve maksimum toplam bellek üzerinde sınırlara sahiptir. Ayrıca, bu veri yapılarından birindeki öğeler her zaman tek bir bölümde bulunur. Bu veri yapılarından birine yapılan her istek, aynı bölüme yapılan bir istektir.

Bir sıralı harita veya kuyruk öğe veya bellek sınırına ulaştığında, gereksiz öğeleri manuel olarak kaldırın veya bir sonlandırma politikası ekleyin. Eğer yalnızca bellek sınırı sınırlamaya neden oluyorsa, anahtarlar ve değerlerden gereksiz bilgileri kaldırarak öğe boyutlarını azaltın.

Tüm öğelerinize ihtiyacınız varsa veya istek hacminden dolayı sınırlama yaşıyorsanız, tek çözüm parçalama (sharding) olacaktır.

Yükü parçalama ile dağıtın

Parçalama, ilişkili bir veri kümesini birden fazla veri yapısına dağıtma sürecidir. Başka bir deyişle, mevcut, yüksek hacimli bir veri yapısını alıp, orijinalinin içerdiği aynı veri kümesini içeren birden fazla daha küçük veri yapısıyla değiştirmek anlamına gelir.

Parçalamanın ana zorluğu, verileri birden fazla veri yapısına yaymanın bir yolunu bulmaktır; bu, orijinalinin aynı işlevselliğini korur.

Roblox zaten hash haritalarını bölümlere ayırsa da, istekleri birkaç anahtar arasında yayarak daha fazla parçalayabilirsiniz.

Sıralı bir haritayı parçalama

Bir sıralı haritada oyuncu kayıtlarını parçalamak için, her Id'yi sabit sayıda haritadan birine atamak için modüler aritmetik kullanın. Aşağıdaki örnek dört harita kullanır ve aynı kullanıcıyı her zaman aynı haritaya yönlendirir:

-- Bellek Deposu Servisini Başlat
local MemoryStoreService = game:GetService("MemoryStoreService")

-- Sıralı Harita kovanlarınızı oluşturun
local sm1 = MemoryStoreService:GetSortedMap("sm1")
local sm2 = MemoryStoreService:GetSortedMap("sm2")
local sm3 = MemoryStoreService:GetSortedMap("sm3")
local sm4 = MemoryStoreService:GetSortedMap("sm4")
local sortedMaps = { sm1, sm2, sm3, sm4 }

-- Öğenin Anahtarından doğru kovayı almak için yardımcı işlev
local function getSortedMapBucket(userId)
	local bucketIndex = (userId % #sortedMaps) + 1
	return sortedMaps[bucketIndex]
end

-- Varsayılan değeri 0 olan oyuncuları başlat
for _, player in game:GetService("Players"):GetPlayers() do
	local userId = player.User.Id
	local bucket = getSortedMapBucket(userId)
	bucket:SetAsync(tostring(userId), 0, 600)
end

-- Bir oyuncunun değerini al
local player = game:GetService("Players"):GetPlayers()[1]
local userId = player.User.Id
local bucket = getSortedMapBucket(userId)
local playerScore = bucket:GetAsync(tostring(userId))
print(playerScore)

Bir kuyruğu parçalama

Bir kuyruğu parçalamak, bir sıralı haritayı parçalamaktan daha zordur. İstek hacmini birden fazla kuyruk arasında yaymak isteseniz de, eklemeler, okumalar ve kaldırmalar yalnızca kuyruğun önünde veya arkasında gerçekleşir.

Bir çözüm, döner bir kuyruk kullanmaktır; bu, birden fazla kuyruk oluşturmak ve bir öğe eklerken veya okurken bunlar arasında döngü yapmaktır:

1. Birkaç kuyruk oluşturun ve bunları bir diziye ekleyin.
2. Okumak ve öğeleri kaldırmak istediğiniz kuyruğu temsil eden bir yerel işaretçi oluşturun. Diğer işaretçi ise öğe eklemek istediğiniz kuyruğu temsil eder:

   • Okuma işlemleri için, her kuyruktan ihtiyaç duyduğunuz öğe sayısını ve okuma işaretçisini nereye taşıyacağınızı hesaplayın.
   • Kaldırma işlemleri için, okunan ID'leri her kuyruğa geçirin.
   • Ekleme işlemleri için, ekleme işaretçisindeki kuyruğa ekleyin ve işaretçiyi artırın.

-- Bellek Deposu Servisini Başlat
local MemoryStoreService = game:GetService("MemoryStoreService")

-- Kuyruklarınızı oluşturun
local q1 = MemoryStoreService:GetQueue("q1")
local q2 = MemoryStoreService:GetQueue("q2")
local q3 = MemoryStoreService:GetQueue("q3")
local q4 = MemoryStoreService:GetQueue("q4")

-- Kuyrukları bir Diziye Ekleyin
local queueArr = { q1, q2, q3, q4 }

-- Okuma ve ekleme kuyruklarının indekslerini temsil eden iki işaretçi oluşturun
local readIndex = 1
local addIndex = 1

-- İndeksleri uygun şekilde güncelleyen yerel bir işlev oluşturun
local function rotateIndex(index, n)
	return (index + n - 1) % 4 + 1
end

-- Kuyruktan n öğe okuyan yerel bir işlev oluşturun
local function readFromQueue(count, allOrNothing, waitTimeout)
	local endIndex = count % 4
	local countPerQueue = count // 4
	local items = {}
	local ids = {}

	-- her kuyruğu döngü ile geçin
	for i = 1, 4, 1 do
		-- bu kuyruğun ekstra bir öğe okuyup okumayacağını belirleyin
		local diff = i - readIndex
		if diff < 0 then
			diff += 4
		end

		local queue = queueArr[i]

		-- her kuyruktan öğeleri okuyun
		-- +1 öğe ekstra okuma kriterlerini karşılıyorsa
		if diff < endIndex then
			items[i], ids[i] = queue:ReadAsync(countPerQueue + 1, allOrNothing, waitTimeout)
		else
			items[i], ids[i] = queue:ReadAsync(countPerQueue, allOrNothing, waitTimeout)
		end
	end

	readIndex = rotateIndex(readIndex, count)

	return items, ids
end

-- Kuyruktan n öğe kaldıran yerel bir işlev oluşturun
local function removeFromQueue(ids)
	for i = 1, 4, 1 do
		local queue = queueArr[i]
		queue:RemoveAsync(ids[i])
	end
end

-- Kuyruğa bir öğe ekleyen yerel bir işlev oluşturun
local function addToQueue(itemKey, expiration, priority)
	local queue = queueArr[addIndex]
	queue:AddAsync(itemKey, expiration, priority)
	addIndex = rotateIndex(addIndex, 1)
end

-- Biraz kod yazın!

for _, player in game:GetService("Players"):GetPlayers() do
	addToQueue(player.User.Id, 600, 0)
end

local players, ids = readFromQueue(20, true, -1)
removeFromQueue(ids)

Hash haritaları

Hash haritalarının bireysel bellek veya öğe sayısı sınırları yoktur ve otomatik olarak parçalanır, ancak bunları kötü kullanırsanız yine de sınırlama ile karşılaşabilirsiniz.

Örneğin, metadata adlı tek bir anahtarın değeri olarak saklanan bir veri hash haritasını düşünün. Eğer bu metadata, yer ID'si, oyuncu sayısı gibi bilgileri içeren iç içe bir nesne içeriyorsa, metadata her gerektiğinde GetAsync("metadata") çağrısı yaparak tüm nesneyi almak zorundasınız. Bu durumda, tüm istekler tek bir anahtara ve dolayısıyla tek bir bölüme gider.

Tüm metadata'yı tek bir iç içe nesne olarak saklamak yerine, her bağımsız erişilen alanı kendi anahtarı olarak saklayın, böylece hash haritası otomatik parçalamadan yararlanabilir. Eğer metadata ile hash haritasının geri kalanı arasında ayrım yapmanız gerekiyorsa, user_count yerine metadata_user_count gibi bir adlandırma öneki ekleyin.

Eğer bir veya birkaç anahtar sık sık istek alıyorsa, bu çağrıları birden fazla anahtar arasında parçalayın. Örneğin, tüm oyun sunucuları bir hash harita anahtarından bir değer alıyorsa, istekler bölüm sınırlamasına neden olabilir. Yükü azaltmak için, değeri birden fazla anahtara kopyalayın ve her sunucuyu kararlı bir parçaya yönlendirin.