feat(Lib): resource

Author: litlighilit

src/pylib/Lib/resource.nim

@@ -0,0 +1,6 @@
+
+import ./resource_impl/[
+  funcs, consts, types
+]
+
+export funcs, consts, types

src/pylib/Lib/resource_impl/consts.nim

@@ -0,0 +1,44 @@
+
+from ./csyms import SIZEOF_RLIMIT_T
+
+const RLIM_INFINITY* =
+  when SIZEOF_RLIMIT_T == 8:
+    0xffffffffffffffffu
+  else:
+    0xffffffffu
+
+template wrap(name){.dirty.} =
+  let `c name`{.importc: astToStr(name), header: "<sys/resource.h>".}: cint
+  let name* = int `c name`
+template wrap(name, os){.dirty.} =
+  when defined(os):
+    wrap(name)
+
+wrap(RLIMIT_CORE)
+wrap(RLIMIT_CPU)
+wrap(RLIMIT_FSIZE)
+wrap(RLIMIT_DATA)
+wrap(RLIMIT_STACK)
+wrap(RLIMIT_RSS)
+wrap(RLIMIT_NPROC)
+wrap(RLIMIT_NOFILE)
+wrap(RLIMIT_OFILE)
+wrap(RLIMIT_MEMLOCK)
+wrap(RLIMIT_VMEM, freebsd)
+wrap(RLIMIT_AS)
+when defined(linux):
+  wrap(RLIMIT_MSGQUEUE)
+  wrap(RLIMIT_NICE)
+  wrap(RLIMIT_RTPRIO)
+  wrap(RLIMIT_RTTIME)
+  wrap(RLIMIT_SIGPENDING)
+when defined(freebsd):
+  wrap(RLIMIT_SBSIZE)
+  wrap(RLIMIT_SWAP)
+  wrap(RLIMIT_NPTS)
+  wrap(RLIMIT_KQUEUES)
+
+wrap(RUSAGE_SELF)
+wrap(RUSAGE_CHILDREN)
+wrap(RUSAGE_BOTH)
+wrap(RUSAGE_THREAD)

src/pylib/Lib/resource_impl/csyms.nim

@@ -0,0 +1,3 @@
+
+import ../../pyconfig/resource
+export resource

src/pylib/Lib/resource_impl/funcs.nim

@@ -0,0 +1,87 @@
+
+import ./types
+import std/posix except EINVAL, EPERM
+import ../n_errno
+import ../../pyerrors/oserr
+from ./csyms import HAVE_PRLIMIT, HAVE_GETPAGESIZE, HAVE_SYSCONF_PAGE_SIZE
+
+proc getrusage*(who: int): struct_rusage =
+  var ru: posix.RUsage
+  if getrusage(who.cint, addr ru) == -1:
+    if isErr(EINVAL):
+      raise newException(ValueError, "Invalid who value")
+    raiseErrno()
+  ru.toPyObject()
+
+type
+  py_rlimit* = tuple
+    rlim_cur: int
+    rlim_max: int
+
+# XXX: NIM-BUG: rlim_cur and rlim_max are int over unsigned in std/posix
+
+proc py2rlimit(limits: py_rlimit, rl_out: var RLimit) =
+  rl_out.rlim_cur = limits.rlim_cur
+  rl_out.rlim_max = limits.rlim_max
+
+proc rlimit2py(rl_in: RLimit): py_rlimit = (rl_in.rlim_cur, rl_in.rlim_max)
+
+let RLIM_NLIMITS{.importc, header: "<sys/resource.h>".}: cint
+
+proc checked_resource*(resource: int): cint =
+  if resource < 0 or resource >= RLIM_NLIMITS:
+    raise newException(ValueError, "Invalid resource specified")
+  cast[cint](resource)
+
+proc getrlimit*(resource: int): py_rlimit =
+  var rl: RLimit
+  if getrlimit(checked_resource(resource), rl) == -1:
+    raiseErrno()
+  rlimit2py(rl)
+
+proc raise_inval =
+  raise newException(ValueError, "current limit exceeds maximum limit")
+proc setrlimit*(resource: int, limits: py_rlimit) =
+  var rl: RLimit
+  py2rlimit(limits, rl)
+  if setrlimit(checked_resource(resource), rl) == -1:
+    if isErr(EINVAL): raise_inval()
+    elif isErr(EPERM):
+      raise newException(ValueError, "not allowed to raise maximum limit")
+    raiseErrno()
+
+when HAVE_PRLIMIT:
+  proc prlimit(pid: Pid, resource: cint, new_limit: ptr RLimit, old_limit: var RLimit): cint {.
+    importc, header: "<sys/resource.h>".}
+
+  proc prlimit*(pid: int, resource: int): py_rlimit{.discardable.} =
+    let
+      pid = Pid pid
+      resource = checked_resource(resource)
+    var old_limit: RLimit
+    if prlimit(pid, resource, nil, old_limit) == -1:
+      if isErr(EINVAL): raise_inval()
+      raiseErrno()
+    rlimit2py(old_limit)
+
+  proc prlimit*(pid: int, resource: int, limits: py_rlimit): py_rlimit{.discardable.} =
+    let
+      pid = Pid pid
+      resource = checked_resource(resource)
+    var old_limit, new_limit: RLimit
+    
+    py2rlimit(limits, new_limit)
+    if prlimit(pid, resource, addr new_limit, old_limit) == -1:
+      if isErr(EINVAL): raise_inval()
+      raiseErrno()
+    
+    rlimit2py(old_limit)
+
+when HAVE_GETPAGESIZE:
+  proc c_getpagesize(): cint{.importc, header: "<unistd.h>".}
+  proc getpagesize*(): int = int c_getpagesize()
+elif HAVE_SYSCONF_PAGE_SIZE:
+  let SC_PAGE_SIZE{.importc, header: "<unistd.h>".}: cint
+  proc c_sysconf(name: cint): cint{.importc, header: "<unistd.h>".}
+  proc getpagesize*(): int = int c_sysconf(SC_PAGE_SIZE)
+

src/pylib/Lib/resource_impl/types.nim

@@ -0,0 +1,44 @@
+
+import std/posix
+
+type
+  struct_rusage* = ref object
+    ru_utime*: float
+    ru_stime*: float
+    ru_maxrss*: int
+    ru_ixrss*: int
+    ru_idrss*: int
+    ru_isrss*: int
+    ru_minflt*: int
+    ru_majflt*: int
+    ru_nswap*: int
+    ru_inblock*: int
+    ru_oublock*: int
+    ru_msgsnd*: int
+    ru_msgrcv*: int
+    ru_nsignals*: int
+    ru_nvcsw*: int
+    ru_nivcsw*: int
+
+template doubletime(tv: TimeVal): float =
+  float(tv.tv_sec) + float(tv.tv_usec) / 1000000.0
+
+proc toPyObject*(rusage: RUsage): struct_rusage =
+  struct_rusage(
+    ru_utime: doubletime(rusage.ru_utime),
+    ru_stime: doubletime(rusage.ru_stime),
+    ru_maxrss: rusage.ru_maxrss,
+    ru_ixrss: rusage.ru_ixrss,
+    ru_idrss: rusage.ru_idrss,
+    ru_isrss: rusage.ru_isrss,
+    ru_minflt: rusage.ru_minflt,
+    ru_majflt: rusage.ru_majflt,
+    ru_nswap: rusage.ru_nswap,
+    ru_inblock: rusage.ru_inblock,
+    ru_oublock: rusage.ru_oublock,
+    ru_msgsnd: rusage.ru_msgsnd,
+    ru_msgrcv: rusage.ru_msgrcv,
+    ru_nsignals: rusage.ru_nsignals,
+    ru_nvcsw: rusage.ru_nvcsw,
+    ru_nivcsw: rusage.ru_nivcsw
+  )

src/pylib/pyconfig/resource.nim

@@ -0,0 +1,23 @@
+
+import ./util
+
+const SIZEOF_RLIMIT_T* = from_c_int(SIZEOF_RLIMIT_T, 8):
+  {.emit: """/*INCLUDESECTION*/
+#include <sys/resource.h>
+#define SIZEOF_RLIMIT_T sizeof(rlim_t)
+""".}
+
+AC_LINK_IFELSE HAVE_PRLIMIT, false:
+  import std/posix
+  proc prlimit(pid: Pid, resource: cint, new_limit, old_limit: ptr RLimit): cint {.
+    importc, header: "<sys/resource.h>".}
+  discard prlimit(0, 0, nil, nil)
+
+AC_LINK_IFELSE HAVE_GETPAGESIZE, false:
+  proc getpagesize(): cint {.importc, header: "<unistd.h>".}
+  discard getpagesize()
+
+AC_LINK_IFELSE HAVE_SYSCONF_PAGE_SIZE, false:
+  let SC_PAGE_SIZE{.importc, header: "<unistd.h>".}: cint
+  proc sysconf(name: cint): cint {.importc, header: "<unistd.h>".}
+  discard sysconf(SC_PAGE_SIZE)