@platforma-sdk/workflow-tengo 6.13.0 → 6.15.0

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

@@ -410,8 +410,14 @@ workflow := func() {
 	pframeCounter := 0
 
 	cpu := undefined
+	cpuFloor := undefined
+	cpuIntercept := undefined
+	cpuSlope := undefined
+	cpuCeiling := undefined
 	mem := undefined
 	memFloor := undefined
+	memSlope := undefined
+	memIntercept := undefined
 	polarsMaxThreads := undefined
 	scratchFreeSpace := undefined
 	inputCache := undefined
@@ -870,6 +876,17 @@ workflow := func() {
 
 
 
+
+
+
+
+
+
+
+
+
+
+
 		cpu: func(amount) {
 			cpu = amount
 			return self
@@ -882,6 +899,61 @@ workflow := func() {
 
 
 
+		cpuFloor: func(cores) {
+			sizing.assertCpuCores(cores, "cpuFloor")
+			cpuFloor = cores
+			return self
+		},
+
+
+
+
+
+
+
+
+		cpuIntercept: func(cores) {
+			sizing.assertCpuCores(cores, "cpuIntercept")
+			cpuIntercept = cores
+			return self
+		},
+
+
+
+
+
+
+
+
+
+
+		cpuSlope: func(slope) {
+			sizing.assertCpuSlope(slope)
+			cpuSlope = slope
+			return self
+		},
+
+
+
+
+
+
+
+
+
+		cpuCeiling: func(cores) {
+			sizing.assertCpuCores(cores, "cpuCeiling")
+			cpuCeiling = cores
+			return self
+		},
+
+
+
+
+
+
+
+
 
 
 
@@ -909,6 +981,11 @@ workflow := func() {
 
 
 
+
+
+
+
+
 		mem: func(amount) {
 			mem = amount
 			return self
@@ -927,6 +1004,11 @@ workflow := func() {
 
 
 
+		memFloor: func(amount) {
+			sizing.assertRamFloor(amount)
+			memFloor = amount
+			return self
+		},
 
 
 
@@ -934,13 +1016,25 @@ workflow := func() {
 
 
 
-		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)
-			memFloor = amount
+
+
+
+		memSlope: func(slope) {
+			sizing.assertRamSlope(slope)
+			memSlope = slope
+			return self
+		},
+
+
+
+
+
+
+
+
+		memIntercept: func(amount) {
+			sizing.assertRamIntercept(amount)
+			memIntercept = amount
 			return self
 		},
 
@@ -1070,8 +1164,14 @@ workflow := func() {
 			runMetaInputs := {
 				queue: queue,
 				cpu: cpu,
+				cpuFloor: cpuFloor,
+				cpuIntercept: cpuIntercept,
+				cpuSlope: cpuSlope,
+				cpuCeiling: cpuCeiling,
 				mem: mem,
 				memFloor: memFloor,
+				memSlope: memSlope,
+				memIntercept: memIntercept,
 				polarsMaxThreads: polarsMaxThreads,
 				scratchFreeSpace: scratchFreeSpace,
 				inputCache: inputCache

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

@@ -41,6 +41,14 @@
 
 
 
+
+
+
+
+
+
+
+
 
 
 
@@ -54,11 +62,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
@@ -110,25 +118,56 @@ polarsMaxThreadsExpr := func(threads) {
 
 
 
+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)
+}
 
 
-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
-	}
+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)
+}
+
+
 
-	return f.size({ default: 0 }).times(RAM_SLOPE).plus(f.gib(RAM_INTERCEPT_GIB)).
-		between(floor, cap).
+
+
+
+
+
+
+
+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(slope).plus(f.const(intercept)).
+		atLeast(f.const(floor)).
 		staticFallback(fallback)
 }
 
@@ -138,10 +177,90 @@ ramFormula := func(memFloor) {
 
 
 
-cpuFormula := func() {
-	return f.size({ default: 0 }).dividedByFloor(f.gib(CPU_GIB_PER_CORE)).plus(f.const(CPU_MIN)).
-		between(f.const(CPU_MIN), f.const(CPU_MAX)).
-		staticFallback(CPU_MIN)
+assertCpuCores := func(cores, name) {
+	ll.assert(is_int(cores) && cores >= 1,
+		"pt.sizing: %s must be an integer of at least 1, got %v", name, cores)
+}
+
+
+
+
+
+
+assertCpuSlope := func(slope) {
+	ll.assert((is_int(slope) || is_float(slope)) && slope >= 0,
+		"pt.sizing: cpuSlope must be a number of at least 0, got %v", slope)
+}
+
+
+
+
+
+
+
+
+
+cpuSlopeHundredths := func(slope) {
+	assertCpuSlope(slope)
+	return int(float(slope) * 100 + 0.000001)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+cpuFormula := func(...args) {
+	ll.assert(len(args) <= 1, "pt.sizing.cpuFormula: expected at most one options map")
+	opts := len(args) == 1 && !is_undefined(args[0]) ? args[0] : {}
+	ll.assert(is_map(opts), "pt.sizing.cpuFormula: expected an options map, got %v", opts)
+
+	floor := is_undefined(opts.floor) ? CPU_MIN : opts.floor
+	intercept := is_undefined(opts.intercept) ? CPU_MIN : opts.intercept
+	assertCpuCores(floor, "cpuFloor")
+	assertCpuCores(intercept, "cpuIntercept")
+
+
+
+	slopeTerm := f.size({ default: 0 }).dividedByFloor(f.gib(CPU_GIB_PER_CORE))
+	if !is_undefined(opts.slope) {
+		slopeTerm = f.size({ default: 0 }).times(cpuSlopeHundredths(opts.slope)).dividedByFloor(f.gib(100))
+	}
+	curve := slopeTerm.plus(f.const(intercept))
+	defaultCurve := is_undefined(opts.slope) && is_undefined(opts.intercept)
+
+	ceiling := undefined
+	if !is_undefined(opts.ceiling) {
+		assertCpuCores(opts.ceiling, "cpuCeiling")
+		ll.assert(opts.ceiling >= floor,
+			"pt.sizing: cpuCeiling (%d) must not be less than cpuFloor (%d)", opts.ceiling, floor)
+		ceiling = opts.ceiling
+	} else if defaultCurve {
+		ceiling = floor > CPU_MAX ? floor : CPU_MAX
+	}
+
+
+	fallback := intercept > floor ? intercept : floor
+	if !is_undefined(ceiling) && fallback > ceiling {
+		fallback = ceiling
+	}
+
+	if is_undefined(ceiling) {
+		return curve.atLeast(f.const(floor)).staticFallback(fallback)
+	}
+	return curve.between(f.const(floor), f.const(ceiling)).staticFallback(fallback)
 }
 
 
@@ -164,7 +283,12 @@ scratchFormula := func(readFrames, writeFrames) {
 
 export {
 	ramFormula: ramFormula,
+	assertRamSlope: assertRamSlope,
+	assertRamIntercept: assertRamIntercept,
+	assertRamFloor: assertRamFloor,
 	cpuFormula: cpuFormula,
+	assertCpuCores: assertCpuCores,
+	assertCpuSlope: assertCpuSlope,
 	scratchFormula: scratchFormula,
 	polarsMaxThreadsExpr: polarsMaxThreadsExpr,
 	assertPolarsMaxThreads: assertPolarsMaxThreads,
@@ -175,9 +299,10 @@ export {
 
 
 	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.13.0",
+  "version": "6.15.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -19,8 +19,8 @@
     "@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.9"