Enhancement & bugfix for the on demand spawning strategy

src/pyworker.c

@@ -75,6 +75,16 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 		"Worker[%d] Waiting request with %s.%s()", wrk_id,
 		py_entrypoint, PYENTRY_FUNNAME);
 
+
+	sop.sem_op = 1; //indicate worker as ready & idle
+	if(semop(semid, &sop, 1) < 0)
+	{
+		err = errno;
+		syslog(LOG_ERR,
+		       "Worker[%d] error incrementing the semaphore : %s",
+		       wrk_id, strerror(err));
+	}
+
 	count = 0;
 	while ((!count || count != max_reqs) && FCGI_Accept() >= 0)
 	{

src/responder.c

@@ -35,12 +35,14 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 	pid_t ret;
 	struct sembuf sop;
 	struct timespec timeout;
+	short idle;
 
 	sop.sem_num = 0;
 	sop.sem_op = 0;
 	sop.sem_flg = 0;
 	timeout.tv_sec = 0;
 	timeout.tv_nsec = 100000000;
+	idle = 0;
 
 	syslog(LOG_INFO, "Preparing workers");
 
@@ -66,6 +68,8 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 	{
 		wrk_pids[n_wrk] = spawn(py_entrypoint, n_wrk, semid, max_reqs);
 	}
+	//Wait at least for a process to be ready
+	while(!semtimedop(semid, &sop, 1, &timeout));
 
 	// main loop, taking care to restart terminated workers, 
 	// spawn new one if needed, etc.
@@ -95,6 +99,18 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 				       ret);
 				continue;
 			}
+			idle=0;
+			sop.sem_op = -1;
+			ret = semop(semid, &sop, 1);
+			sop.sem_op = 0;
+			if(ret < 0)
+			{
+				err = errno;
+				syslog(LOG_ALERT,
+				       "Unable to dec sem after child exit : %s",
+				       strerror(err));
+				clean_exit(err);
+			}
 			if(status)
 			{
 				syslog(LOG_WARNING,
@@ -110,29 +126,34 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 			// child stopped, looking for it
 			if(wanted_n < n_wrk)
 			{	// need to shift the list and dec n_wrk
+				syslog(LOG_DEBUG, "GC Workers");
+syslog( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 				memmove(wrk_pids+n, wrk_pids+n+1,
 				        sizeof(pid_t) * (n_wrk - n));
 				n_wrk--;
 			}
 			else
 			{	// respawn on same slot
+				syslog(LOG_INFO, "respawn #%d", n);
 				wrk_pids[n] = spawn(py_entrypoint, n,
 				                    semid, max_reqs);
+				continue;
 			}
 		}
-		if(n_wrk == max_wrk)
-		{
-			nanosleep(&timeout, NULL);
-			continue;
-		}
 		ret = semtimedop(semid, &sop, 1, &timeout);
+syslog( LOG_DEBUG, "semtimeop ret=%d want %d have %d", ret, wanted_n, n_wrk);
 		if(ret < 0)
 		{
 			err = errno;
 			if(err == EAGAIN)
 			{
+syslog(LOG_DEBUG, "IDLE want %d have %d\t min=%d", wanted_n, n_wrk, min_wrk);
 				// workers idle
-				if(wanted_n > min_wrk)
+				if(!idle)
+				{
+					idle = 1;
+				}
+				else if(wanted_n > min_wrk && n_wrk - wanted_n < 2)
 				{
 					wanted_n--;
 				}
@@ -141,8 +162,9 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 			syslog(LOG_ERR, "Unable to read semaphore : %s",
 			       strerror(err));
 		}
-		if(!ret)
+		if(!ret && n_wrk < max_wrk)
 		{
+			idle=0;
 			syslog( LOG_DEBUG,
 				"All workers busy, spawning a new one");
 			n = n_wrk;
@@ -168,21 +190,10 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 pid_t spawn(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 {
 	pid_t res;
-	struct sembuf sop;
-	int err;
+	struct timespec timeout;
+	timeout.tv_sec = 0;
+	timeout.tv_nsec = 100000000;
 	
-	sop.sem_num = 0;
-	sop.sem_op = 1;
-	sop.sem_flg = 0;
-
-	if(semop(semid, &sop, 1) < 0)
-	{
-		err = errno;
-		syslog(LOG_ALERT,
-		       "Failed to semop before spawning a child : %s",
-		       strerror(errno));
-		clean_exit(err);
-	}
 
 	res = fork();
 	if(res == -1)
@@ -196,6 +207,10 @@ pid_t spawn(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 		// Child process
 		exit(work(py_entrypoint, wrk_id, semid, max_reqs));
 	}
+	// Sleep to avoid spawning like hell thinking all workers are
+	// busy. Let some time to this one to go up...
+	// TODO: find a better way to avoid spawning to max_wrk
+	nanosleep(&timeout, NULL);
 	syslog(	LOG_INFO,
 		"Worker #%d spawned with PID %d", wrk_id, res);
 	return res;