[go-nuts] Go runtime modified to check memory and execution time

The place for enforcing quotas is not in the Go runtime. Use your
operating system's resource quota technology.

Also, measuring memory consumption accurately is complex business,
there's no such thing as "my program uses xMB of memory" in the world
of virtual memory systems. You have to be very precise about what kind
of questions you ask. Fortunately, the quota mechanisms allows for
this fine grained caps.

The issue is that I want a solution for all systems (where Go runs) and
since I know, Windows --I'm not user of such sytem-- does not enables to
limit resources like memory.

Also, measuring memory consumption accurately is complex business,
for programs untrusted downloaded from Internet.
Of course, I've in mind packages like syscall, functions of "os", etc, for
that such programs can not damage the system where they are run.

It's been a while, thankfully, since I had to deal with Windows, but it likely
has this mechanism as well, just done differently.

In general, I don't think it's useful to push features into a language because
a target OS does not natively support that feature. Otherwise, the language
turns into an OS ;)
The Go compiler is NOT like a VM and cannot be depended upon to limit damage
caused by untrusted programs. You need a sandbox for that.

I would review the code for play.golang.org (IIRC it's available somewhere).

You'll find that you need an actual VM of some kind to do this effectively, which
obviates the need for Windows compatibility and provides the level of control you need
to implement it correctly.

-Gyepi

I mean the Go runtime, not the Go compiler. The runtime, among other
things, control goroutines and get information of the system like number of
CPUs, etc, so I don't see any problem to modify the runtime to do some
checks.

I would review the code for play.golang.org (IIRC it's available
Yep, using a VM is the thing that all people has used until now.

It's possible to do, but it will give you very weak guarantees
(because a program can allocate memory bypassing runtime and it can
run subprocesses). OS provided means are definitely more robust. For
the execution time you definitely just want to setup a timer in the
parent (your) process.

To answer your question. For memory consumption you need to modify
mem_GOOS.c files in runtime to check for total memory consumption
after any allocations. For execution time you can start a separate
goroutine that will kill the process after timeout, look at how
scavenger goroutine is started within runtime.