Best Practices beim Entwerfen von MemoryStore-Datenstrukturen

Abhängig von der eingeben, MemoryStoreService enforces Grenzen auf der Speicher und der Anzahl der Elemente in einer Datenstruktur. Alle Datenstrukturen sind auch durch einen globalen pro-Partition-Anforderungslimit eingeschränkt.

Jede Roblox-Erfahrung hat das Memory-Store-Observability-Dashboard, das ein Set von Diagrammen enthält, die Sie verwenden können, um die Verwendung des Speicherstands zu überwachen.

Sortierte Karten und Warteschlange

Sortierte Karten und Warteschlange haben beide Grenzen für die maximale Anzahl von Elementen und die maximale Gesamtmemória. Darüber hinaus befinden sich die Elemente in einer dieser Datenstrukturen immer auf einer einzigenPartition. Jeder Anruf auf eine dieser Datenstrukturen ist ein Anruf auf die gleichePartition.

Wenn eine sortierte Karte oder eine Warteschlange ihren Gegenstand oder Speicherlimit erreicht, ist der beste Kurs der Aktion die manuelle Entfernung von nicht benötigten Elementen oder durch das Hinzufügen eines Verfallszeitlimits für die Elemente. Alternativ kannst du versuchen, die Größe deiner Elemente zu reduzieren, indem du überflüssige Informationen aus deinen Schlüsseln und Werten entfernst.

Wenn Sie alle Ihre Artikel benötigen oder durch Anfragen begrenzt werden, ist die einzige Lösung Sharding.

Scheren

Die Aufteilung ist der Prozess, bei dem ein Set von verwandten Daten in mehreren Datenstrukturen gespeichert wird. In anderen Worten bedeutet es, ein bestehendes, hochskaliges Datenstruktur zu nehmen und es durch mehrere, kleinere zu ersetzen, die zusammen das gleiche Set von Daten enthalten wie das ursprüngliche.

Die Schlüsselherausforderung beim Teilen ist es, einen Weg zu finden, die Daten auf mehrere Datenstrukturen aufzuteilen, der die gleiche Funktionalität wie das Original gewährleistet.

Eine sortierte Karte aufteilen

Um eine sortierte Karte in mehrere alphabetische Unterabschnitte mit Zeichenbereichen zu schneiden, berücksichtigen Sie, Ihre Daten in alphabetische Unterabschnitte mit Zeichenbereichen zu unterteilen. Zum Beispiel nehmen Sie an, dass Sie nur mit dem ersten Buchstaben von A-Z Schlüssel haben und Sie glauben, dass vier sortierte Karten für Ihren aktuellen Anwendungsfall und Ihren zukünftigen Wachstum ausreichen:

• Die erste Karte kann A-G, die zweite H-N, die dritte O-T und die vierte U-Z abdecken.
• Um ein Artikeleinzufügen oder abzurufen, verwenden Sie die entsprechende Karte basierend auf dem Startcharakter des Artikel.

Eine sortierte Karte aufteilen
-- Beginnen Sie mit dem MemoryStore Service
local MemoryStoreService = game:GetService("MemoryStoreService")

-- Erstellen Sie Ihre sortierten Kisten
local sm_AtoG = MemoryStoreService:GetSortedMap("AtoG")
local sm_HtoM = MemoryStoreService:GetSortedMap("HtoM")
local sm_NtoT = MemoryStoreService:GetSortedMap("NtoT")
local sm_UtoZ = MemoryStoreService:GetSortedMap("UtoZ")

-- Funktion zum Abrufen des richtigen Behälters aus dem Item Key
local function getSortedMapBucket(itemKey)
	if (itemKey >= "a" and itemKey < "h") then
		return sm_AtoG
	elseif (itemKey < "n") then
		return sm_HtoM
	elseif (itemKey < "u") then
		return sm_NtoT
	else
		return sm_UtoZ
	end
end

-- Spieler-Namen mit Standardwert 0 initialisieren
for _, player in game:GetService("Players"):GetPlayers() do
	local bucket = getSortedMapBucket(player)
	bucket:SetAsync(player, 0, 600)
end

-- Werte eines Spieler:inabrufen
local player = "myPlayer"
local bucket = getSortedMapBucket(player)
local playerScore = bucket:GetAsync(player)
print(playerScore)

Eine Warteschlange schneiden

Das Teilen einer Warteschlange ist komplizierter als das Teilen einer sortierten Karte. Obwohl Sie die Anforderungsausgabe auf mehrere Warteschlange verteilen möchten, fügt, liest und entfernt nur jemals an der Vorder- oder Rückseite der Warteschlange stattfindet.

Eine Lösung ist es, eine drehende Warteschlange zu verwenden, was bedeutet, dass Sie mehrere Warteschlange erstellen und zwischen ihnen drehen, wenn Sie ein Artikelhinzufügen oder lesen:

1. Erstellen Sie mehrere Warteschlange und fügen Sie sie einem Array hinzu.

2. Erstellen Sie zwei lokale Zeiger. Einer stellt die Warteschlange dar, von der Sie lesen und entfernen möchten. Der andere stellt die Warteschlange dar, zu der Sie Gegenstände hinzufügen möchten:

   • Für Les operations berechnen Sie die Anzahl der Elemente, die Sie von jeder Warteschlange benötigen, sowie den Ort, an den Sie den Lesepunkt verschieben möchten.
   • Für Entfernungen verwenden Sie die IDs von der Lektüre zu jeder Warteschlange.
   • Für Add-Operationen fügen Sie dem Warteschlangen-Zeiger hinzu und erhöhen Sie den Zeiger.

Eine Warteschlange schneiden
-- Beginnen Sie mit dem MemoryStore Service
local MemoryStoreService = game:GetService("MemoryStoreService")

-- Erstellen Sie Ihre Warteschlange
local q1 = MemoryStoreService:GetQueue("q1")
local q2 = MemoryStoreService:GetQueue("q2")
local q3 = MemoryStoreService:GetQueue("q3")
local q4 = MemoryStoreService:GetQueue("q4")

-- Lege die Warteschlange in ein Array
local queueArr = { q1, q2, q3, q4 }

-- Erstellen Sie zwei Zeiger, die die Indizes der Lektüre repräsentieren, und fügen Sie Warteschlange hinzu
local readIndex = 1
local addIndex = 1

-- Erstellen Sie eine lokale Funktion, die die Indizes richtig aktualisiert
local function rotateIndex(index, n)
	return (index + n - 1) % 4 + 1
end

-- Erstellen Sie eine lokale Funktion, die n Elemente aus der Warteschlange liest
local function readFromQueue(count, allOrNothing, waitTimeout)
	local endIndex = count % 4
	local countPerQueue = count // 4
	local items = {}
	local ids = {}

	-- loop durch jede warteschlange
	for i = 1, 4, 1 do
		-- bestimmen, ob diese warteschlange ein zusätzliches artikelliest
		local diff = i - readIndex
		if diff < 0 then
			diff += 4
		end

		local queue = queueArr[i]

		-- lesen sie artikel aus jeder warteschlange
		-- +1 artikel wenn die zusätzlichen lesungskriterien erfüllt werden
		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

-- Erstellen Sie eine lokale Funktion, die n Elemente aus der Warteschlange entfernt
local function removeFromQueue(ids)
	for i = 1, 4, 1 do
		local queue = queueArr[readIndex]
		queue:RemoveAsync(ids[i])
	end
end

-- Erstellen Sie eine lokale Funktion, die einen Artikel zur Warteschlange hinzufügt
local function addToQueue(itemKey, expiration, priority)
	local queue = queueArr[readIndex]
	queue:AddAsync(itemKey, expiration, priority)
	addIndex = rotateIndex(addIndex, 1)
end

-- Schreiben Sie einige Codes!

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

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

Hashen-Karten

Hash-Karten haben keine einzelnen Speicher- oder Element-Count-Limit und werden automatisch in mehrere Teile aufgeteilt, aber du kannst immer noch eine Verzögerung erleiden, wenn du sie schlecht verwendest.

Zum Beispiel, berücksichtigen Sie ein Erlebnis mit einer Hashen-Karte von Spieldaten, die als Wert eines einzelnen Schlüssels namens metadata gespeichert ist. Wenn dieses Metadaten ein verdrehtes Objekt mit Informationen wie Platz-ID, Spieleranzahl usw. enthält, hat jedes Mal, wenn das Metadaten benötigt wird, keine Wahl, als GetAsync("metadata") und das

Statt alle Metadaten als ein einzelnes, verschachteltes Objekt zu speichern, ist der bessere Ansatz, jedes Feld als seinen eigenen Schlüssel zu speichern, damit die Hashes-Karte von der automatischen Teilung profitieren kann. Wenn Sie die Trennung zwischen Metadaten und dem Rest der Hashes-Karte benötigen, fügen Sie ein Namenspräfix hinzu (z. B. metadata_user_count , anstatt nur user_count .