use fixed array of ctx to avoid consuming all fds

[Ivansete-status]

Use fixed array of 32 context to allow reuse them and hence, prevent app from running out of file descriptors.
Notice that this is mostly needed for testing purposes. For example, we detected an issue when dealing with Go unit tests that started/stopped several contexts, without recycling, and then the test process run out of FDs.

closes #4

p.s.: there are some other minor changes like enhancing the error handling, use of wait signal in watchdog to allow fast shutdown (and make tests faster.)

[gmelodie]

We could have a single cleanup proc and add a freeCtx: bool = false (or default to true, if that makes more sense)

[gmelodie]

wdSignaled is the same as above, should have the same name. I'd just called it stop or maybe stopSignaled, but call it that everywhere

[gmelodie]

Besides the other comments, do we even use this at all?

proc destroyFFIContext[T](ctx: ptr FFIContext[T]): Result[void, string] =

I see that tests introduced all use pool.destroyFFIContext

[gmelodie]

nit: maybe this comment should be inside the definition of genBindings? Here it may cause confusion as to what it refers to

[Ivansete-status]

Addressed in 397150e

[gmelodie]

TIL about quote!

[gmelodie]

Suggested change

	for i in 0 ..< MaxFFIContexts:
	var expected = false
	const expected = false
	for i in 0 ..< MaxFFIContexts:

[Ivansete-status]

Thanks but compareExchange in atomics requires a var:

proc compareExchange[T: not Trivial](location: var Atomic[T]; expected: var T;
                                     desired: T; order: MemoryOrder = moSequentiallyConsistent): bool

[gmelodie]

This line seems to be the only difference between the two destroyFFIContext implementations, maybe we could wrap the rest in another function and make the two impls call the new function? e.g.

proc newFn(ctx...) =
  unregisterCtx(cast[pointer](ctx))
  ...
  joinThread(ctx.ffiThread)
  joinThread(ctx.watchdogThread)

# then ...
  
proc destroyFFIContext*[T](
    pool: var FFIContextPool[T], ctx: ptr FFIContext[T]
): Result[void, string] =
  newFn(ctx)
  pool.releaseSlot(ctx)
  return ok()

# and ...

proc destroyFFIContext[T](ctx: ptr FFIContext[T]): Result[void, string] =
  newFn(ctx)
  ctx.cleanUpResources().isOkOr:
    return err("cleanUpResources failed: " & $error)
  return ok()

[Ivansete-status]

I think it was confusing because both had the same name but one call the other.
The b53f3ce may have enhanced that.

[NagyZoltanPeter]

Yepp, this is needed but I see a bit of discrepancy in between we reserve slots and store the ctx pointer in there while we have another store for ctx ptrs.
I suggest a bit of rework here, eliminate that contextRegistry for which we always do a lock at every api call and just use the slot registry for the same puropse - for validating the ctx ptr - reading slot registry does not need a lock.

[Ivansete-status]

Besides the other comments, do we even use this at all?

proc destroyFFIContext[T](ctx: ptr FFIContext[T]): Result[void, string] =

@gmelodie - this proc is needed to clear the context. I renamed it in the following, to avoid confusion:
b53f3ce

[Ivansete-status]

Yepp, this is needed but I see a bit of discrepancy ...

Wow! Great catch, thanks @NagyZoltanPeter !
I didn't properly solve the conflicts after rebasing and it got messy. I think it is better now. Addressed in dbc5852