Possible to use inside an http.Handler? about quickjs HOT 6 CLOSED

package quickjs

import (
	"context"
	"fmt"
	"runtime"

	"github.com/lithdew/quickjs"
)

// NewWorker creates a new worker
// Worker is not goroutine safe
func NewWorker() *Worker {
	runtime := quickjs.NewRuntime()
	return &Worker{runtime}
}

// Worker struct
type Worker struct {
	runtime quickjs.Runtime
}

// Eval function
func (w *Worker) Eval(ctx context.Context, js string, v interface{}) (err error) {
	context := w.runtime.NewContext()
	defer context.Free()
	result, err := context.Eval(js)
	if err != nil {
		return err
	}
	switch t := v.(type) {
	case *string: // we expect a string
		if !result.IsString() {
			return fmt.Errorf("Eval expected a string, but received %q", result)
		}
		*t = result.String()
		result.Free()
		return nil

	case *int64:
		if !result.IsNumber() {
			return fmt.Errorf("Eval expected a number, but received %q", result)
		}
		*t = result.Int64()
		result.Free()
		return nil

	case *bool:
		if !result.IsBool() {
			return fmt.Errorf("Eval expected a boolean, but received %q", result)
		}
		*t = result.Bool()
		result.Free()
		return nil
	case nil: // ignore the output
		result.Free()
		return nil
	default:
		result.Free()
		return fmt.Errorf("quickjs.Eval: unable to coerce into expected value %t", t)
	}
}

// Close the worker
func (w *Worker) Close() {
	w.runtime.Free()
}

// NewPool creates a pool of workers
func NewPool(size int) *Pool {
	requestCh := make(chan request, size)
	pool := &Pool{requestCh}
	// start all available workers
	for i := 0; i < size; i++ {
		go pool.worker(i)
	}
	return pool
}

// Pool of workers
type Pool struct {
	requestCh chan request
}

// TODO: sometimes goroutines get scheduled on the same thread.
// then they're locked to that thread. You can see this with
// -trace. Is there anyway to force the goroutines to get
// scheduled on different threads?
//
// Even better, is it possible to remove this requirement
// entirely? By cleaning up state after each run or something?
func (p *Pool) worker(id int) {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	w := NewWorker()
	defer w.Close()
	for req := range p.requestCh {
		err := w.Eval(req.ctx, req.js, req.result)
		req.response <- response{err}
	}
}

type request struct {
	ctx      context.Context
	js       string
	result   interface{}
	response chan response
}

type response struct {
	err error
}

// Eval the worker
func (p *Pool) Eval(ctx context.Context, js string, result interface{}) (err error) {
	response := make(chan response)
	p.requestCh <- request{ctx, js, result, response}
	res := <-response
	return res.err
}

// Close the pool
func (p *Pool) Close() {
	close(p.requestCh)
}

package quickjs_test

import (
	"context"
	"fmt"
	"runtime"
	"testing"
	"time"

	"github.com/matthewmueller/duo/internal/quickjs"
	"github.com/tj/assert"
	"golang.org/x/sync/errgroup"
)

const slow = `
function slow(baseNumber){
	let result = 0;
  for (var i = Math.pow(10, 7); i >= 0; i--) {
		result += Math.atan(i) * Math.tan(i);
	};
	return Math.floor(result)
}
slow(10)
`

func TestWorker(t *testing.T) {
	ctx := context.Background()
	var eg errgroup.Group
	eg.Go(func() error {
		worker := quickjs.NewWorker()
		defer worker.Close()
		var result int64
		now := time.Now()
		err := worker.Eval(ctx, slow, &result)
		assert.NoError(t, err)
		fmt.Println(result)
		fmt.Println(time.Since(now))
		var result2 int64
		now2 := time.Now()
		err2 := worker.Eval(ctx, slow, &result2)
		assert.NoError(t, err2)
		fmt.Println(time.Since(now2))
		return nil
	})
	eg.Wait()
	// assert.Equal(t, "11", v)
}

const slow = `
function slow(baseNumber){
	let result = 0;
  for (var i = Math.pow(10, 7); i >= 0; i--) {
		result += Math.atan(i) * Math.tan(i);
	};
	return Math.floor(result)
}
slow(10)
`

func TestPool(t *testing.T) {
	ctx := context.Background()
	pool := quickjs.NewPool(runtime.NumCPU())
	defer pool.Close()
	var eg errgroup.Group
	for i := 0; i < 204; i++ {
		eg.Go(func() error {
			var result int64
			err := pool.Eval(ctx, slow, &result)
			assert.NoError(t, err)
			assert.Equal(t, int64(-2898551), result)
			return nil
		})
	}
	assert.NoError(t, eg.Wait())
}