6 replies to this topic

[jaredallard]

Let's say we have two loop programs

a.lua
b.lua

both do

while (true) do
os.sleep(0)
end

Now, let's say we had a third that could be used too stop any one of those a, or b programs started.

How could I stop the co routine created by the parallel API without it successfully returning.

[Lyqyd]

Why?

[Bomb Bloke]

Short answer is, you don't - that's not how the parallel API's functions are built to work.

You could write similar versions that have that functionality, but depending on what your actual goals are, I'd say it's likely easier to rig your a/b functions so that they can kill themselves (eg, in response to an event fired by your third function).

[ElvishJerricco]

Well you can always get dirty with silly awful hacks. In the exact scenario of each loop just doing sleep(0), you can overwrite sleep to error, yield, then rewrite it back to the original.

But yea that's awful. You're going to need to either not use the parallel API in favor of a custom coroutine management system, or you're going to need the functions that are looping to listen for an event or check a status variable or something along those lines.

Edited by ElvishJerricco, 11 December 2014 - 10:28 AM.

[AgentE382]

The best hack is to override coroutine.status, because the parallel API uses it to check whether a coroutine is still running. So, you could make a kill function like this:

local routinesToKill = {}
local installed
function kill(routine)
  routinesToKill[routine] = true
  if not installed then
	local oldStatus = coroutine.status
	coroutine.status = function(routine)
	  return routinesToKill[routine] and "dead" or oldStatus(routine)
	end
	installed = true
  end
end

That should work, though I just wrote it. Completely untested.

Edited by AgentE382, 11 December 2014 - 01:16 PM.

[ElvishJerricco]

AgentE382, on 11 December 2014 - 01:15 PM, said:

The best hack is to override coroutine.status, because the parallel API uses it to check whether a coroutine is still running. So, you could make a kill function like this:

local routinesToKill = {}
local installed
function kill(routine)
  routinesToKill[routine] = true
  if not installed then
	local oldStatus = coroutine.status
	coroutine.status = function(routine)
	  return routinesToKill[routine] and "dead" or oldStatus(routine)
	end
	installed = true
  end
end

That should work, though I just wrote it. Completely untested.

I don't think he'd have access to the routines though. At least not without calling coroutine.current() from within the threads, which seems to go against the goal of not needed the threads to do anything on their own.

[AgentE382]

ElvishJerricco, on 11 December 2014 - 09:44 PM, said:

AgentE382, on 11 December 2014 - 01:15 PM, said:

The best hack is to override coroutine.status, because the parallel API uses it to check whether a coroutine is still running. So, you could make a kill function like this:

local routinesToKill = {}
local installed
function kill(routine)
  routinesToKill[routine] = true
  if not installed then
	local oldStatus = coroutine.status
	coroutine.status = function(routine)
	  return routinesToKill[routine] and "dead" or oldStatus(routine)
	end
	installed = true
  end
end

That should work, though I just wrote it. Completely untested.

I don't think he'd have access to the routines though. At least not without calling coroutine.current() from within the threads, which seems to go against the goal of not needed the threads to do anything on their own.

Hmm... Tru dat.

I was thinking he'd have access to the routines, since he created them. Obviously, I was mistaken. I forgot how the parallel API works for a bit. If he wants this functionality, he's gonna' have to look at a total replacement of the parallel API... one which allows routine naming / killing.

Edited by AgentE382, 12 December 2014 - 02:42 AM.