I might need to optimize this XD

[honey the codewitch]

The fibers are already allocated since they're simple structs sitting inside an array. The only field that gets set are two simple 32 bit fields on the struct =) Since they're allocated this way, at least unless .NET sucks in this arena (i haven't checked the IL) they don't need to be recycled - they're permanent instances. So a threadpool doesn't buy me anything. These aren't traditional threads.

Real programmers use butterflies

[Greg Utas]

These sound like really lightweight fibers, so .NET must suck at handling them. :)

[honey the codewitch]

No, the issue is most fibers resolve to examination of a single character in the input so if you have 10 of them the same character gets examined as much as 10 times. This is a byproduct of the design of a Pike VM, itself an artifact of the way NFA expressions work so there's very little to be done about it except convert to a DFA (the optimization process) Reduce the fibers and it speeds right up:

NFA ran with 10 max fibers and 3.5 average char passes
NFA+DFA (optimized) ran with 6 max fibers and 2.5 average char passes
DFA ran with 2.5 max fibers and 1 average char passes
Pass #1
NFA: Lexed in 1.575287 msec
NFA+DFA (optimized): Lexed in 1.054843 msec
DFA: Lexed in 0.901254 msec
Pass #2
NFA: Lexed in 1.529819 msec
NFA+DFA (optimized): Lexed in 1.100836 msec
DFA: Lexed in 0.830835 msec
Pass #3
NFA: Lexed in 1.523334 msec
NFA+DFA (optimized): Lexed in 1.049213 msec
DFA: Lexed in 0.851737 msec
Pass #4
NFA: Lexed in 1.400265 msec
NFA+DFA (optimized): Lexed in 1.03485 msec
DFA: Lexed in 0.829009 msec

Real programmers use butterflies

[Jon McKee]

Eddy Vluggen wrote:

So, light weight threads that are short-lived?

Kinda. Their primary purpose is non-preemptive/cooperative multitasking instead of preemptive multitasking like threads. The best analogy I've seen is co-routines.

[honey the codewitch]

Yep. That's about the long and short of it.

private struct _Fiber
{
public readonly int[][] Program;
public readonly int Index;
public int[] Saved;
public _Fiber(int[][] program, int index,int[] saved)
{
Program = program;
Index = index;
Saved = saved;
}
public _Fiber(_Fiber fiber, int index,int[] saved)
{
Program = fiber.Program;
Index = index;
Saved = saved;
}
}

All it contains is a pointer to the program array which all fibers share, the current instruction pointer, and any saved cursor position (only used in the event of the "save" instruction) Creating them is cheap since I just use a straight array to hold them all and it basically never gets resized, so all of them are already "live" just waiting to have their fields filled in.

Real programmers use butterflies

[Jorgen Andersson]

If I have understood it correctly: yield uses fibers, foreach uses yield. So try to swap a few well chosen foreach loops for classic for loops and see what happens.

Wrong is evil and must be defeated. - Jeff Ello

[honey the codewitch]

I'm not using any foreach loops. I've already optimized the VM itself to within an inch of its life

Real programmers use butterflies

[Jorgen Andersson]

How about Linq?

Wrong is evil and must be defeated. - Jeff Ello

[honey the codewitch]

I thought the goal was to speed this up?

Real programmers use butterflies

[ZTransform]

Lounge?

[Jorgen Andersson]

I didn't tell you to use it, I'm just looking for problems. :-)

Wrong is evil and must be defeated. - Jeff Ello

[honey the codewitch]

Yes, this is the Lounge.

Real programmers use butterflies

[honey the codewitch]

Look away. Here's almost all of it. The stuff you don't see is very thin

public static int Run(int[][] prog,LexContext input)
{
input.EnsureStarted();
int i,match=-1;
_Fiber[] currentFibers, nextFibers, tmp;
int currentFiberCount=0, nextFiberCount=0;
int[] pc;
// position in input
int sp=0;
// stores our captured input
var sb = new StringBuilder(64);
int[] saved, matched;
saved = new int[2];
currentFibers = new _Fiber[prog.Length];
nextFibers = new _Fiber[prog.Length];
_EnqueueFiber(ref currentFiberCount, ref currentFibers, new _Fiber(prog,0, saved), 0);
matched = null;
var cur = -1;
if (LexContext.EndOfInput != input.Current)
{
var ch1 = unchecked((char)input.Current);
if (char.IsHighSurrogate(ch1))
{
if (-1 == input.Advance())
throw new ExpectingException("Expecting low surrogate in unicode stream. The input source is corrupt or not valid Unicode", input.Line, input.Column, input.Position, input.FileOrUrl);
var ch2 = unchecked((char)input.Current);
cur = char.ConvertToUtf32(ch1, ch2);
}
else
cur = ch1;

}
		
while(0

[Jorgen Andersson]

In the sticky post at the top: 2. Technical discussions are welcome...[^]

Wrong is evil and must be defeated. - Jeff Ello

[Jorgen Andersson]

Oh, no wonder then, you're doing it on purpose... :laugh:

Wrong is evil and must be defeated. - Jeff Ello

[honey the codewitch]

Doing what on purpose? I'm a little slow this morning. :)

Real programmers use butterflies

[Jorgen Andersson]

Spawning loads of fibers. Or is this auto generated code again?

Wrong is evil and must be defeated. - Jeff Ello

[honey the codewitch]

Well, it's not on purpose per se. I mean yes, I'm spawning a lot of them, but the idea is to keep as few active or "alive" at one time as possible. when I see a jmp with 3 operands it spawns 2 fibers in addition to a primary fiber. That's what I don't want, since every fiber has to examine the character under the cursor which leads to many examinations of the same character. There's no way to optimize this out because it's rather the point of the fiber running in the first place. Multiple examinations are a byproduct of the NFA algorithm. My goal is simply to reduce/eliminate the amount of jmps and especially the number of operands they have. A pure DFA can run by examining each character only once.

Real programmers use butterflies