julec: add the --COMAXPROCS command-line argument to set a custom COMAXPROCS value

Author: mertcandav

src/julec/compile.jule

@@ -24,6 +24,7 @@ use "std/strings"
 let mut OutDir = "dist"
 let mut OutName = "ir.cpp"
 let mut Out = ""
+let mut COMAXPROCS = "default"
 
 let targets = map[str][]str{
 	"windows": ["amd64", "arm64", "i386"],
@@ -433,6 +434,24 @@ fn checkOptFlag(opt: str) {
 	}
 }
 
+fn checkCOMAXPROCS() {
+	if COMAXPROCS == "default" {
+		env::COMAXPROCS = 0
+		ret
+	}
+	n := conv::ParseUint(COMAXPROCS, 10, 64) else {
+		handle::Throw("--COMAXPROCS: value is not a valid number: " + COMAXPROCS)
+		ret // Avoid error.
+	}
+	if n < 1 {
+		handle::Throw("--COMAXPROCS: invalid value: " + COMAXPROCS)
+	}
+	if n > u64(i32.Max) {
+		handle::Throw("--COMAXPROCS: value is too large: " + COMAXPROCS)
+	}
+	env::COMAXPROCS = i32(n)
+}
+
 fn checkCppStdFlag() {
 	match env::CppStd {
 	| "cpp20":
@@ -448,6 +467,7 @@ fn checkFlags(args: []str): []str {
 
 	mut fs := flag::FlagSet.New()
 
+	fs.AddVar[str](unsafe { (&str)(&COMAXPROCS) }, "COMAXPROCS", 0, "Maximum number of Ps that can execute coroutines")
 	fs.AddVar[str](unsafe { (&str)(&opt) }, "opt", 0, "Optimization level")
 	fs.AddVar[str](unsafe { (&str)(&target) }, "target", 0, "Target system")
 	fs.AddVar[str](unsafe { (&str)(&Out) }, "out", 'o', "Output identifier")
@@ -488,6 +508,7 @@ fn checkFlags(args: []str): []str {
 	checkCppStdFlag()
 	checkTargetFlag(target)
 	checkOptFlag(opt)
+	checkCOMAXPROCS()
 
 	ret content
 }

src/julec/env/compiler.jule

@@ -24,4 +24,7 @@ let mut RC = true
 let mut Safety = true
 
 // Production compilation.
-let mut Production = false
+let mut Production = false
+
+// The comaxprocs value.
+let mut COMAXPROCS: i32 = 0

src/julec/main.jule

@@ -134,7 +134,13 @@ The most common arguments are:
 		architecture imititation and IR will be generated accordingly.
 		But it will be compiled with your native target.
 		Use the "julec tool targets" to see valid targets.
-		The value "native-native" equals to your native target.`)
+		The value "native-native" equals to your native target.
+	--COMAXPROCS <value>
+		Sets the maximum number of Ps that can execute coroutines concurrently.
+		Pass "default" to explicitly use the runtime default.
+		The value must be a valid integer and at least 1.
+		The default may vary by machine and is a reasonable choice for most programs,
+		optimized for overall concurrency.`)
 	| CmdTest:
 		println(`The test command compiles the packages named by the import paths for testing.
 
@@ -179,7 +185,13 @@ The most common arguments are:
 		architecture imititation and IR will be generated accordingly.
 		But it will be compiled with your native target.
 		Use the "julec tool targets" to see valid targets.
-		The value "native-native" equals to your native target.`)
+		The value "native-native" equals to your native target.
+	--COMAXPROCS <value>
+		Sets the maximum number of Ps that can execute coroutines concurrently.
+		Pass "default" to explicitly use the runtime default.
+		The value must be a valid integer and at least 1.
+		The default may vary by machine and is a reasonable choice for most programs,
+		optimized for overall concurrency.`)
 	| CmdMod:
 		println(`The mod command is a tool managing your jule modules.
 

src/julec/obj/cxx/object.jule

@@ -1581,6 +1581,7 @@ impl ObjectCoder {
 				v == meta::Program.Runtime.Qpcfreq ||
 				v == meta::Program.Runtime.Asynctime ||
 				v == meta::Program.Runtime.Blocking ||
+				v == meta::Program.Runtime.Comaxprocs ||
 				v == meta::Program.Runtime.TimebaseNumer ||
 				v == meta::Program.Runtime.TimebaseDenom {
 				continue
@@ -1641,11 +1642,19 @@ impl ObjectCoder {
 	__jule_envp = reinterpret_cast<__jule_U8**>(envp);
 
 	`)
+		// Initialize the "asynctime" runtime variable.
 		identCoder.var(&self.Buf, meta::Program.Runtime.Asynctime)
 		self.write(" = ")
 		self.ec.boolean(asyncRuntime)
 		self.write(";\n")
 		self.indent()
+		// Initialize the "comaxprocs" runtime variable.
+		identCoder.var(&self.Buf, meta::Program.Runtime.Comaxprocs)
+		self.write(" = ")
+		itoa(&self.Buf, i64(env::COMAXPROCS))
+		self.write(";\n")
+		self.indent()
+
 		identCoder.funcIns(&self.Buf, meta::Program.Runtime.Init)
 		self.write("();\n\n")
 		self.initGlobals()

src/julec/obj/meta/meta.jule

@@ -41,6 +41,7 @@ struct Runtime {
 	Sched:         &sema::Var
 	Asynctime:     &sema::Var
 	Blocking:      &sema::Var
+	Comaxprocs:    &sema::Var
 	TimebaseNumer: &sema::Var // Darwin
 	TimebaseDenom: &sema::Var // Darwin
 	Kq:            &sema::Var // Darwin
@@ -141,6 +142,7 @@ fn CollectRuntime(mut ir: &obj::IR): &Runtime {
 	meta.Sched = obj::RuntimeFindGlobal(p, "sched")
 	meta.Asynctime = obj::RuntimeFindGlobal(p, "asynctime")
 	meta.Blocking = obj::RuntimeFindGlobal(p, "blocking")
+	meta.Comaxprocs = obj::RuntimeFindGlobal(p, "comaxprocs")
 	meta.TimebaseNumer = p.FindVar("timebaseNumer", false) // Darwin
 	meta.TimebaseDenom = p.FindVar("timebaseDenom", false) // Darwin
 	meta.Kq = p.FindVar("kq", false)                       // Darwin

std/runtime/proc.jule

@@ -178,8 +178,13 @@ extern fn __jule_trampolineRun()
 // Calls schedthread with P.
 extern let __jule_trampoline_schedthread: *unsafe
 
+// The value of the COMAXPROCS.
+// Compiler will set it to zero for default value, which is initialized by runtime.
+// Otherwise, this is initialized by the compiler to a custom value before runtime initialized.
+let mut comaxprocs: i32 = 0
+
 // Returns the maximum number of CPUs that can be executing simultaneously.
-fn COMAXPROCS(): int { ret numcpu }
+fn COMAXPROCS(): int { ret int(comaxprocs) }
 
 const (
 	// The maximum count of the runnable coroutine queue of a P.
@@ -909,7 +914,7 @@ top:
 	//
 	// Stealing is limited to a small fixed number of attempts to
 	// avoid excessive contention and cache thrashing.
-	if m.spinning || 2*atomic::Load(&sched.nmspinning, atomic::Relaxed) < i32(COMAXPROCS())-atomic::Load(&sched.npidle, atomic::Relaxed) {
+	if m.spinning || 2*atomic::Load(&sched.nmspinning, atomic::Relaxed) < comaxprocs-atomic::Load(&sched.npidle, atomic::Relaxed) {
 		if !m.spinning {
 			becomeSpinning(m)
 		}
@@ -1255,6 +1260,13 @@ async fn yield() {
 	park2(&m.c, tg, reasonNA).await
 }
 
+fn asynctimeinit() {
+	// Initialize the comaxprocs variable.
+	if comaxprocs == 0 {
+		comaxprocs = i32(numcpu)
+	}
+}
+
 #disable nilptr boundary
 fn schedinit() {
 	// Initialize the global scheduler instance.
@@ -1266,7 +1278,7 @@ fn schedinit() {
 	// Because we are in the program initialize state, no concurrency risk.
 
 	// Initialize Ps.
-	maxprocs := i32(COMAXPROCS())
+	maxprocs := comaxprocs
 	sched.allp = make([]&p, maxprocs)
 	sched.npidle = maxprocs - sched.nm
 	mut i := i32(0)
@@ -1329,6 +1341,11 @@ fn sysmon() {
 	}
 }
 
+fn sysmoninit() {
+	// Start the sysmon thread.
+	unsafe { threadSpawn((*unsafe)(uintptr(sysmon)), nil) }
+}
+
 // Schedules some M to run the P (creates an M if necessary).
 // If P==nil, the behavior is undefined. P is always should be a valid pointer.
 // If spinning is set, the caller has incremented nmspinning and must provide a

std/runtime/runtime.jule

@@ -27,6 +27,11 @@ fn __init() {
 	// And globally initialized map values ​​will use different hashes.
 	// Same key may not match, avoid this implementation mistake.
 	hashinit()
+	// Initialize the common asynctime.
+	// This funtion inititializes only commons for sync and async runtime.
+	// Such as COMAXPROCS, which may be used by sync runtime.
+	asynctimeinit()
+	// Initialize the asynctime specifics.
 	if asynctime {
 		// Initialize thread pool for blocking jobs.
 		blockinginit()
@@ -37,9 +42,4 @@ fn __init() {
 		// Initialize and start sysmon.
 		sysmoninit()
 	}
-}
-
-// Starts the sysmon thread.
-fn sysmoninit() {
-	unsafe { threadSpawn((*unsafe)(uintptr(sysmon)), nil) }
 }

std/sync/waitgroup.jule

@@ -9,7 +9,7 @@ use "std/sync/atomic"
 // The main coroutine calls [WaitGroup.Add] to set the number of
 // coroutines to wait for. Then each of the coroutines runs and
 // calls [WaitGroup.Done] when finished. At the same time,
-// [WaitGroup.Wait] can be used to block until all goroutines have finished.
+// [WaitGroup.Wait] can be used to block until all coroutines have finished.
 //
 // A WaitGroup must not be copied after first use.
 struct WaitGroup {