Is :ConnectParallel() more performant?

[BullfrogBait]

I tried looking around and it seems like a lot of people know what it is but so little are giving examples of when to use it, how to use it and if it saves on performance.

PlayersService.PlayerAdded:ConnectParallel(RegisterPlayer)
WorkspaceService.DescendantAdded:ConnectParallel(RegisterPart)

local function RegisterPart(BasePart)
	if  BasePart:IsA("BasePart")
		and BasePart.CanCollide == true
		and BasePart.Parent:FindFirstChildWhichIsA("Humanoid") == nil
	then
		table.insert(PartRegistry, BasePart)
	end
end

I’m currently using it on any connection that can support it, am I using it wrong?

[alexinite (alex)]

@EthicalRobot

The Basics of Parallelism

In order for your script to run in parallel with another script two things must be true:

• The scripts must be parented under different Actor instances
• The thread within a script must be desynchronized either via task.desynchronize() or Signal::ConnectParallel

@EthicalRobot

RBXScriptSignal:ConnectParallel

Instead of using task.desynchronize in signals, you can alternatively use a new ConnectParallel method. This method will run your code in parallel when that signal is triggered, which is more efficient than using Connect + task.desynchronize .

A common pattern for parallel execution that we expect to see is:

RunService.Heartbeat:ConnectParallel(function ()
    ... -- some parallel code that computes a state update
    task.synchronize()
    ... -- some serial code that changes the state of instances
end)

For the time being you will need to put all of the code that changes Instance properties in the serial portion of the update, while future releases will allow you to move more code from the serial to the parallel portion.

Parallel Lua Beta

It allows execution of multiple tasks in parallel, thus performing them at the same time. There are multiple issues with this. First of all, different threads will finish at different times depending on the workload. This can cause inconsistencies and you’ll have to yield the rest of the code until the working threads finish to avoid missing information. Next up, multiple threads can access and write the same information. Most other languages introduce mutex, while Luau has task.synchronize. W…

Gathered from Parallel Lua Beta - Updates / Announcements

From my knowledge, making it run in parallel will sync related (or exact) signals together.
Let’s say you were listening to Heartbeat in multiple scripts for example, instead of running them individually it will realize that there’s multiple and run Heartbeat once and execute everything using Heartbeat at once, instead of happening multiple times.

Now if I get this right, the Actor has to be different but the Signal which is being read has to be the same. If you’re reading the ChildAdded of Part1 and Part2 and parallel them, it will not execute at the same time (for obvious, performant reasons). However, if you were listening to ChildAdded in two different scripts it’s good practice to use ConnectParallel to lower RBXScriptSignal events firing too much.

In practicality, if it’s a signal for an event that is only connected once, just use Signal::Connect.

[alexinite (alex)]

-- Good Practice

-- Script 1
local RunService = game:GetService('RunService')
RunService.Heartbeat:ConnectParallel(function()
    -- do something
end

-- Script 2
local RunService = game:GetService('RunService')
RunService.Heartbeat:ConnectParallel(function()
    -- do a different thing
end

These will run at the same time and only fire RunService.Heartbeat once.

-- Bad Practice

-- Script 1
local Part1 = workspace.Part1
Part1.ChildAdded:ConnectParallel(function(Child)
    -- do something
end

-- Script 2
local Part2 = workspace.Part2
Part2.ChildAdded:ConnectParallel(function(Child)
    -- do another thing
end

Even though these are Parallel Signals, these will not run at the same time. This is because it is a signal for a different Instance. If these were both for workspace.Part1 or vice versa however, this would be acceptable.

Since they’re not, it only makes sense to just use Signal::Connect

[BullfrogBait]

Edit: Nevermind, I figured it out. Thank you for your clarifications though!

[Wyzloc]

Does anyone know a scenario where this method (ConnectParallel) would come into play?

[alexinite (alex)]

If you have something running on the same context thread and multiple things are listening to the same event, ConnectParallel may be a good option. Usually in an environment with good practice, there really should never be multiple listeners for one event: but if there was this will make it more effective.

It’s been a while since I’ve actually looked into this, but I don’t know if ConnectParallel relies on the new Deferred event mode. That would be something important to note.

[lolmanurfunny (lolman)]

Assuming you’re familiar with task.desynchronize: