เทคนิคการออกแบบโครงสร้างข้อมูลของหน่วยจำเก็บข้อมูล

พิมพ์เมมอร์สโตร์เซอร์วิสจะบังคับ ขีดจำกัด บนหน่วยความจำและจำนวนรายการในโครงสร้างข้อมูล ทุกโครงสร้างข้อมูลต้องถูกจำกัดโดยขีดจำกัดการร้องขอขนาดรวม

แต่ละประสบการณ์ Roblox มี แผงควบคุมความโปร่งใสของหน่วยเก็บข้อมูลแห่งหน่วยความจำ ซึ่งรวมถึงชุดของกราฟิกที่คุณสามารถใช้เพื่อตรวจสอบการใช้หน่วยเก็บข้อมูลแห่งหน่วยความจำ

แผนที่และคิว

แมพและคิวทั้งสองมีขีดจำกัดที่ชัดเจนที่สุดสำหรับจำนวนรวมของรายการและหน่วยความจำสูงสุด นอกจากนี้ รายการในหนึ่งในโครงสร้างข้อมูลเหล่านี้จะอยู่บนผนวกเดียว ทุกคำขอไปยังหนึ่งในโครงสร้

เมื่อแผนที่หรือคิวที่เรียบเรียงถึงขีดจำกัดของตัวอย่างหรือหน่วยความจำของมัน สิ่งที่ดีที่สุดคือการลบรายการที่ไม่จำเป็นออกจากกุญแจและค่าของคุณหรือโดยการเพิ่มนโยบาย

หากคุณต้องการรายการทั้งหมดหรือกำลังประสบปัญหาการระงับการทำงานเนื่องจากปริมาณคำขอผ่านการร้องขอ ทางเดียวที่จะแก้ปัญหาคือการแบ่ง

แบ่ง

การแบ่งย่อยคือกระบวนการสตรีมข้อมูลที่เกี่ยวข้องกันในหลายโครงสร้างข้อมูล ในคำอื่น มันหมายถึงการนำข้อมูลที่มีอยู่แล้วของข้อมูลและแทนที่ด้วยข้อมูลขนาดเล็กที่มีข้อมูลเดียวกันกับข้อม

ความท้าทายหลักในการแบ่งย่อยคือการค้นหาวิธีการแผ่กระจายข้อมูลไปยังโครงสร้างข้อมูลหลายระดับโดยมีความสามารถเดียวกับของเดิม

แบ่งแผนที่ที่เรียบเรียง

เพื่อแบ่งแผนที่ที่เรียบเรียง โปรดพิจารณาแบ่งข้อมูลของคุณเป็นระเบียบาละกันด้วยช่วงตัวอักษร โปรดใช้ตัวอักษรตัวแรกจาก A-Z เป็นตัวอย่าง และคุณเชื่อว่าสี่แผนที่แบ่งจะเพียงพอสำหรับก

• แผนแรกสามารถครอบคลุม A-G, H-N, O-T และ U-Z
• ไอเท็มไอเท็ม

แบ่งแผนที่ที่เรียบเรียง
-- เริ่มต้นบริการห้องเก็บข้อมูล
local MemoryStoreService = game:GetService("MemoryStoreService")

-- สร้างถังแมพของคุณแบบเรียงลำดับ
local sm_AtoG = MemoryStoreService:GetSortedMap("AtoG")
local sm_HtoM = MemoryStoreService:GetSortedMap("HtoM")
local sm_NtoT = MemoryStoreService:GetSortedMap("NtoT")
local sm_UtoZ = MemoryStoreService:GetSortedMap("UtoZ")

-- ระบบช่วยเหลือในการดึงกลับถังที่ถูกต้องจาก 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

-- ใช้ชื่อผู้เล่นด้วยค่าเริ่มต้นของ 0
for _, player in game:GetService("Players"):GetPlayers() do
	local bucket = getSortedMapBucket(player)
	bucket:SetAsync(player, 0, 600)
end

-- ดึงค่าของผู้เล่น
local player = "myPlayer"
local bucket = getSortedMapBucket(player)
local playerScore = bucket:GetAsync(player)
print(playerScore)

แบ่ง Queue

การแบ่งห้องเป็นสองส่วนเป็นเรื่องยากกว่าการแบ่งห้องเป็นสองส่วน แม้ว่าคุณต้องการแผ่การส่งผ่านการร้องขอไปยังห้องต่างๆ ในหลายคิว แต่ก็เพิ่มเติม อ่าน และลบเฉพาะเมื่ออยู่ที่ด้านหน้าหรือด้า

หนึ่งในแกนตรีการจัดการคิวคือการใช้คิวหมุนซึ่งหมายถึงการสร้างคิวหลายคิวและหมุนระหว่างพวกเขาเมื่อคุณเพิ่มหรืออ่านรายการ:

1. สร้างคิวหลายและเพิ่มพวกเขาลงในรายการ

2. สร้างสองตัวชี้นำภายใน หนึ่งแทนตัวคิวที่คุณต้องการอ่านและลบรายการออก อีกคนแทนตัวคิวที่คุณต้องการเพิ่มรายการ:

   • สำหรับการอ่าน คำนวณจำนวนรายการที่คุณต้องการจากแต่ละคิว และยังคำนวณตำแหน่งที่ต้องย้ายตัวอ่าน
   • สำหรับการลบ, ส่ง ID จากคิวหนึ่งไปยังอื่น
   • สำหรับการเพิ่มตัวอักษรใหม่ ให้เพิ่มไปยังคิวที่ตรงนั้นและเพิ่มตัวอักษร

แบ่ง Queue
-- เริ่มต้นบริการห้องเก็บข้อมูล
local MemoryStoreService = game:GetService("MemoryStoreService")

-- สร้างคิวของคุณ
local q1 = MemoryStoreService:GetQueue("q1")
local q2 = MemoryStoreService:GetQueue("q2")
local q3 = MemoryStoreService:GetQueue("q3")
local q4 = MemoryStoreService:GetQueue("q4")

-- ใส่คิวในแมทริค
local queueArr = { q1, q2, q3, q4 }

-- สร้างสองตัวแปรที่แทนด้วยดัชนีของการอ่านและเพิ่มคิว
local readIndex = 1
local addIndex = 1

-- สร้างคุณสมบัติที่ปรับปรุงด้วยเวลาที่เหมาะสม
local function rotateIndex(index, n)
	return (index + n - 1) % 4 + 1
end

-- สร้างคุณสมบัติท้องถิ่นที่อ่าน n รายการจากคิว
local function readFromQueue(count, allOrNothing, waitTimeout)
	local endIndex = count % 4
	local countPerQueue = count // 4
	local items = {}
	local ids = {}

	-- ทำซ้ำผ่านแต่ละคิว
	for i = 1, 4, 1 do
		-- ไอเท็ม
		local diff = i - readIndex
		if diff < 0 then
			diff += 4
		end

		local queue = queueArr[i]

		-- อ่านรายการจากแต่ละคิว
		-- +1 รายการหากตรงตามเกณฑ์การอ่านเพิ่มเติม
		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

-- สร้างคุณสมบัติที่เฉพาะเจาะจงที่ลบรายการ n ออกจากคิว
local function removeFromQueue(ids)
	for i = 1, 4, 1 do
		local queue = queueArr[readIndex]
		queue:RemoveAsync(ids[i])
	end
end

-- สร้างคุณสมบัติที่เพิ่มไอเท็มให้กับคิว
local function addToQueue(itemKey, expiration, priority)
	local queue = queueArr[readIndex]
	queue:AddAsync(itemKey, expiration, priority)
	addIndex = rotateIndex(addIndex, 1)
end

-- รหัส!

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

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

แผนที่แฮช

แมพแฮชไม่มีขีดจำกัดของหน่วยความจำหรือจำนวนรายการ และจะแบ่งย่อยโดยอัตโนมัติ แต่คุณยังคงสามารถพบปัญหาการระงับการทำงานได้หากคุณใช้พวกเขาไม่เป็นไปตามวิธีการที่เหมาะสม

เช่น พิจารณาประสบการณ์ที่มีแผนที่แฮชของข้อมูลเกมที่เก็บไว้เป็นมูลค่าของกุญแจเดียวที่มีชื่อว่า metadata หากข้อมูลนี้มีข้อมู

แทนที่จะเก็บรวบรวมข้อมูลทั้งหมดเป็นวัตถุเดียว เช่น ตะวัน หรือ หัวหน้า ในที่สุด การเก็บรวบรวมแต่ละสาขาจะเป็นกุญแจของตัวเอง เพื่อให้แผนที่แ