@platforma-sdk/workflow-tengo 6.12.1 → 6.14.0

package/dist/tengo/lib/pt.lib.tengo

@@ -412,6 +412,9 @@ workflow := func() {
 	cpu := undefined
 	mem := undefined
 	memFloor := undefined
+	memSlope := undefined
+	memIntercept := undefined
+	polarsMaxThreads := undefined
 	scratchFreeSpace := undefined
 	inputCache := undefined
 	queue := execConstants.MEDIUM_QUEUE
@@ -888,8 +891,9 @@ workflow := func() {
 
 
 
-		mem: func(amount) {
-			mem = amount
+		polarsMaxThreads: func(threads) {
+			sizing.assertPolarsMaxThreads(threads)
+			polarsMaxThreads = threads
 			return self
 		},
 
@@ -912,13 +916,26 @@ workflow := func() {
 
 
 
+		mem: func(amount) {
+			mem = amount
+			return self
+		},
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 		memFloor: func(amount) {
-			ll.assert(is_int(amount) && amount > 0,
-				"pt.workflow.memFloor: expected a positive number of bytes, got %v", amount)
-			ll.assert(amount <= sizing.RAM_CAP_GIB * units.GiB,
-				"pt.workflow.memFloor: floor of %v bytes exceeds the %d GiB ceiling of the auto-sized request. Use .mem() for a fixed request above the ceiling.",
-				amount, sizing.RAM_CAP_GIB)
+			sizing.assertRamFloor(amount)
 			memFloor = amount
 			return self
 		},
@@ -932,6 +949,34 @@ workflow := func() {
 
 
 
+		memSlope: func(slope) {
+			sizing.assertRamSlope(slope)
+			memSlope = slope
+			return self
+		},
+
+
+
+
+
+
+
+
+		memIntercept: func(amount) {
+			sizing.assertRamIntercept(amount)
+			memIntercept = amount
+			return self
+		},
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1051,6 +1096,9 @@ workflow := func() {
 				cpu: cpu,
 				mem: mem,
 				memFloor: memFloor,
+				memSlope: memSlope,
+				memIntercept: memIntercept,
+				polarsMaxThreads: polarsMaxThreads,
 				scratchFreeSpace: scratchFreeSpace,
 				inputCache: inputCache
 			}

package/dist/tengo/lib/pt.sizing.lib.tengo

@@ -38,6 +38,15 @@
 
 
 
+
+
+
+
+
+
+
+
+
 
 
 
@@ -52,11 +61,11 @@ f := import("@platforma-sdk/workflow-tengo:exec.formula")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 units := import("@platforma-sdk/workflow-tengo:units")
 
-RAM_INTERCEPT_GIB := 2
-RAM_SLOPE := 6
-RAM_FLOOR_GIB := 2
-RAM_CAP_GIB := 256
-RAM_STATIC_FALLBACK := "4GiB"
+RAM_INTERCEPT_GIB := 4
+RAM_INTERCEPT_MIN_GIB := 4
+RAM_SLOPE := 10
+RAM_SLOPE_MIN := 0
+RAM_FLOOR_GIB := 4
 
 SCRATCH_PER_READ_FRAME := 16
 SCRATCH_SORT := 16
@@ -67,33 +76,97 @@ CPU_MIN := 2
 CPU_MAX := 8
 CPU_GIB_PER_CORE := 16
 
+POLARS_THREADS_MIN := 2
+POLARS_THREADS_DEFAULT := 8
+POLARS_THREADS_GRANTED := "granted"
+
 
-POLARS_MAX_THREADS_EXPR := format("{min(%d,max(%d,system.cpu))}", CPU_MAX, CPU_MIN)
+POLARS_MAX_THREADS_EXPR := format("{min(%d,max(%d,system.cpu))}", POLARS_THREADS_DEFAULT, POLARS_THREADS_MIN)
 
 
 
 
 
 
+assertPolarsMaxThreads := func(threads) {
+	ll.assert((is_int(threads) && threads >= POLARS_THREADS_MIN) || threads == POLARS_THREADS_GRANTED,
+		"pt.sizing: polarsMaxThreads must be an integer of at least %d or %q, got %v",
+		POLARS_THREADS_MIN, POLARS_THREADS_GRANTED, threads)
+}
+
+
 
 
-ramFormula := func(memFloor) {
-	floor := f.gib(RAM_FLOOR_GIB)
-	cap := f.gib(RAM_CAP_GIB)
-	fallback := RAM_STATIC_FALLBACK
 
-	if !is_undefined(memFloor) {
 
 
 
-		ll.assert(memFloor <= RAM_CAP_GIB * units.GiB,
-			"pt.sizing: memFloor (%v bytes) must not exceed the %d GiB ceiling", memFloor, RAM_CAP_GIB)
-		floor = f.const(memFloor)
-		fallback = memFloor
+polarsMaxThreadsExpr := func(threads) {
+	if is_undefined(threads) {
+		return POLARS_MAX_THREADS_EXPR
 	}
+	assertPolarsMaxThreads(threads)
+	if threads == POLARS_THREADS_GRANTED {
+		return format("{max(%d,system.cpu)}", POLARS_THREADS_MIN)
+	}
+	return format("{min(%d,max(%d,system.cpu))}", threads, POLARS_THREADS_MIN)
+}
+
+
+
+
+
+
+assertRamSlope := func(slope) {
+	ll.assert(is_int(slope) && slope >= RAM_SLOPE_MIN,
+		"pt.sizing: memory slope must be an integer of at least %d, got %v", RAM_SLOPE_MIN, slope)
+}
+
+
+
+
+
+
+assertRamIntercept := func(intercept) {
+	ll.assert(is_int(intercept) && intercept >= RAM_INTERCEPT_MIN_GIB * units.GiB,
+		"pt.sizing: memory intercept must be an integer number of bytes of at least %d GiB, got %v", RAM_INTERCEPT_MIN_GIB, intercept)
+}
+
+
+
+
+
+
+assertRamFloor := func(floor) {
+	ll.assert(is_int(floor) && floor > 0,
+		"pt.sizing: memory floor must be a positive integer number of bytes, got %v", floor)
+}
+
+
+
+
+
+
+
+
+
+
+ramFormula := func(opts) {
+	ll.assert(is_map(opts), "pt.sizing.ramFormula: expected an options map, got %v", opts)
+
+	floor := is_undefined(opts.floor) ? RAM_FLOOR_GIB * units.GiB : opts.floor
+	slope := is_undefined(opts.slope) ? RAM_SLOPE : opts.slope
+	intercept := is_undefined(opts.intercept) ? RAM_INTERCEPT_GIB * units.GiB : opts.intercept
+	assertRamFloor(floor)
+	assertRamSlope(slope)
+	assertRamIntercept(intercept)
+
+
+
+	fallback := intercept > floor ? intercept : floor
 
-	return f.size({ default: 0 }).times(RAM_SLOPE).plus(f.gib(RAM_INTERCEPT_GIB)).
-		between(floor, cap).
+	return f.size({ default: 0 }).times(slope).plus(f.const(intercept)).
+		atLeast(f.const(floor)).
 		staticFallback(fallback)
 }
 
@@ -129,16 +202,24 @@ scratchFormula := func(readFrames, writeFrames) {
 
 export {
 	ramFormula: ramFormula,
+	assertRamSlope: assertRamSlope,
+	assertRamIntercept: assertRamIntercept,
+	assertRamFloor: assertRamFloor,
 	cpuFormula: cpuFormula,
 	scratchFormula: scratchFormula,
+	polarsMaxThreadsExpr: polarsMaxThreadsExpr,
+	assertPolarsMaxThreads: assertPolarsMaxThreads,
 
 	POLARS_MAX_THREADS_EXPR: POLARS_MAX_THREADS_EXPR,
+	POLARS_THREADS_MIN:     POLARS_THREADS_MIN,
+	POLARS_THREADS_DEFAULT: POLARS_THREADS_DEFAULT,
 
 
 	RAM_INTERCEPT_GIB: RAM_INTERCEPT_GIB,
+	RAM_INTERCEPT_MIN_GIB: RAM_INTERCEPT_MIN_GIB,
 	RAM_SLOPE:         RAM_SLOPE,
+	RAM_SLOPE_MIN:     RAM_SLOPE_MIN,
 	RAM_FLOOR_GIB:     RAM_FLOOR_GIB,
-	RAM_CAP_GIB:       RAM_CAP_GIB,
 	CPU_MIN:           CPU_MIN,
 	CPU_MAX:           CPU_MAX,
 	SCRATCH_PER_READ_FRAME:  SCRATCH_PER_READ_FRAME,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.12.1",
+  "version": "6.14.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -19,11 +19,11 @@
     "@milaboratories/pframes-rs-wasip2": "1.1.61",
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.1.1",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.6",
-    "@platforma-open/milaboratories.software-ptabler": "2.1.14"
+    "@platforma-open/milaboratories.software-ptabler": "2.1.14",
+    "@platforma-open/milaboratories.software-ptexter": "1.2.6"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "4.1.2"
+    "@platforma-sdk/tengo-builder": "4.1.9"
   },
   "scripts": {
     "types:check": "pl-tengo imports && pl-tengo check",