* filedef.h (FILE_TIMESTAMP_STAT_MODTIME): Ditto.
Patch provided by Troy Runkel <Troy.Runkel@mathworks.com>
+2011-10-11 Troy Runkel <Troy.Runkel@mathworks.com>
+
+ * config.h.W32: Enable job server support for Windows.
+ * main.c [WINDOWS32]: Include sub_proc.h
+ (main): Create a named semaphore to implement the job server.
+ (clean_jobserver): Free the job server semaphore when make is finished.
+ * job.c [WINDOWS32]: Define WAIT_NOHANG
+ (reap_children): Support non-blocking wait for child processes.
+ (free_child): Release job server semaphore when child process finished.
+ (job_noop): Don't define function on Windows.
+ (set_child_handler_action_flags): Don't define function on Windows.
+ (new_job): Wait for job server semaphore or child process termination.
+ (exec_command): Pass new parameters to process_wait_for_any.
+ * w32/include/sub_proc.h [WINDOWS32]: New/updated EXTERN_DECL entries.
+ * w32/subproc/sub_proc.c [WINDOWS32]: Added job server implementation.
+ (open_jobserver_semaphore): Open existing job server semaphore by name.
+ (create_jobserver_semaphore): Create new job server named semaphore.
+ (free_jobserver_semaphore): Close existing job server semaphore.
+ (acquire_jobserver_semaphore): Decrement job server semaphore count.
+ (release_jobserver_semaphore): Increment job server semaphore count.
+ (has_jobserver_semaphore): Returns whether job server semaphore exists.
+ (get_jobserver_semaphore_name): Returns name of job server semaphore.
+ (wait_for_semaphore_or_child_process): Wait for either the job server
+ semaphore to become signalled or a child process to terminate.
+ (process_wait_for_any_private): Support for non-blocking wait for child.
+ (process_wait_for_any): Added support for non-blocking wait for child.
+ (process_file_io): Pass new parameters to process_wait_for_any_private.
+
2011-09-18 Paul Smith <psmith@gnu.org>
* main.c (main): If we're re-exec'ing and we're the master make,
multiple consecutive backslash/newlines do not condense into one space.
* In recipes, a recipe prefix following a backslash-newlines is removed.
+* New feature: The "job server" capability is now supported on Windows.
+ Implementation contributed by Troy Runkel <Troy.Runkel@mathworks.com>
+
* New feature: "!=" shell assignment operator as an alternative to the
- $(shell ...) function. Implemented for portability of BSD makefiles.
+ $(shell ...) function. Implemented for compatibility with BSD makefiles.
WARNING: Backward-incompatibility!
Variables ending in "!" previously defined as "variable!= value" will now be
interpreted as shell assignment. Change your assignment to add whitespace
# include "sub_proc.h"
# include "w32err.h"
# include "pathstuff.h"
+# define WAIT_NOHANG 1
#endif /* WINDOWS32 */
#ifdef __EMX__
{
#ifndef WINDOWS32
WAIT_T status;
+#endif
/* Initially, assume we have some. */
int reap_more = 1;
-#endif
#ifdef WAIT_NOHANG
# define REAP_MORE reap_more
HANDLE hPID;
int werr;
HANDLE hcTID, hcPID;
+ DWORD dwWaitStatus = 0;
exit_code = 0;
exit_sig = 0;
coredump = 0;
}
/* wait for anything to finish */
- hPID = process_wait_for_any();
+ hPID = process_wait_for_any(block, &dwWaitStatus);
if (hPID)
{
coredump = 0;
}
+ else if (dwWaitStatus == WAIT_FAILED)
+ {
+ /* The WaitForMultipleObjects() failed miserably. Punt. */
+ pfatal_with_name ("WaitForMultipleObjects");
+ }
+ else if (dwWaitStatus == WAIT_TIMEOUT)
+ {
+ /* No child processes are finished. Give up waiting. */
+ reap_more = 0;
+ break;
+ }
+
pid = (pid_t) hPID;
}
#endif /* WINDOWS32 */
/* If we're using the jobserver and this child is not the only outstanding
job, put a token back into the pipe for it. */
+#ifdef WINDOWS32
+ if (has_jobserver_semaphore() && jobserver_tokens > 1)
+ {
+ if (! release_jobserver_semaphore())
+ {
+ DWORD err = GetLastError();
+ fatal (NILF,_("release jobserver semaphore: (Error %d: %s)"),
+ err, map_windows32_error_to_string(err));
+ }
+
+ DB (DB_JOBS, (_("Released token for child %p (%s).\n"), child, child->file->name));
+ }
+#else
if (job_fds[1] >= 0 && jobserver_tokens > 1)
{
char token = '+';
DB (DB_JOBS, (_("Released token for child %p (%s).\n"),
child, child->file->name));
}
+#endif
--jobserver_tokens;
}
#endif
-#ifdef MAKE_JOBSERVER
+#if defined(MAKE_JOBSERVER) && !defined(WINDOWS32)
RETSIGTYPE
job_noop (int sig UNUSED)
{
just once). Also more thought needs to go into the entire algorithm;
this is where the old parallel job code waits, so... */
+#ifdef WINDOWS32
+ else if (has_jobserver_semaphore())
+#else
else if (job_fds[0] >= 0)
+#endif
while (1)
{
char token;
if (!jobserver_tokens)
break;
+#ifndef WINDOWS32
/* Read a token. As long as there's no token available we'll block.
We enable interruptible system calls before the read(2) so that if
we get a SIGCHLD while we're waiting, we'll return with EINTR and
DB (DB_JOBS, ("Duplicate the job FD\n"));
job_rfd = dup (job_fds[0]);
}
+#endif
/* Reap anything that's currently waiting. */
reap_children (0, 0);
if (!children)
fatal (NILF, "INTERNAL: no children as we go to sleep on read\n");
+#ifdef WINDOWS32
+ /* On Windows we simply wait for the jobserver semaphore to become
+ * signalled or one of our child processes to terminate.
+ */
+ got_token = wait_for_semaphore_or_child_process();
+ if (got_token < 0)
+ {
+ DWORD err = GetLastError();
+ fatal (NILF,_("semaphore or child process wait: (Error %d: %s)"),
+ err, map_windows32_error_to_string(err));
+ }
+#else
/* Set interruptible system calls, and read() for a job token. */
set_child_handler_action_flags (1, waiting_jobs != NULL);
got_token = read (job_rfd, &token, 1);
saved_errno = errno;
set_child_handler_action_flags (0, waiting_jobs != NULL);
+#endif
/* If we got one, we're done here. */
if (got_token == 1)
break;
}
+#ifndef WINDOWS32
/* If the error _wasn't_ expected (EINTR or EBADF), punt. Otherwise,
go back and reap_children(), and try again. */
errno = saved_errno;
pfatal_with_name (_("read jobs pipe"));
if (errno == EBADF)
DB (DB_JOBS, ("Read returned EBADF.\n"));
+#endif
}
#endif
}
/* wait and reap last child */
- hWaitPID = process_wait_for_any();
+ hWaitPID = process_wait_for_any(1, 0);
while (hWaitPID)
{
/* was an error found on this process? */
# include <proto/dos.h>
#endif
#ifdef WINDOWS32
-#include <windows.h>
-#include <io.h>
-#include "pathstuff.h"
+# include <windows.h>
+# include <io.h>
+# include "pathstuff.h"
+# include "sub_proc.h"
#endif
#ifdef __EMX__
# include <sys/types.h>
program = strrchr (argv[0], '\\');
if (program)
{
- argv0_len = strlen(program);
+ argv0_len = strlen (program);
if (argv0_len > 4 && streq (&program[argv0_len - 4], ".exe"))
/* Remove .exe extension */
program[argv0_len - 4] = '\0';
define_variable_cname (".SHELLFLAGS", "-c", o_default, 0);
/* Set up .FEATURES
- We must do this in multiple calls because define_variable_cname() is
- a macro and some compilers (MSVC) don't like conditionals in macros. */
+ Use a separate variable because define_variable_cname() is a macro and
+ some compilers (MSVC) don't like conditionals in macros. */
{
const char *features = "target-specific order-only second-expansion"
" else-if shortest-stem undefine oneshell"
while (*ep != '\0' && *ep != '=')
++ep;
#ifdef WINDOWS32
- if (!unix_path && strneq(envp[i], "PATH=", 5))
+ if (!unix_path && strneq (envp[i], "PATH=", 5))
unix_path = ep+1;
- else if (!strnicmp(envp[i], "Path=", 5)) {
+ else if (!strnicmp (envp[i], "Path=", 5)) {
do_not_define = 1; /* it gets defined after loop exits */
if (!windows32_path)
windows32_path = ep+1;
cp = jobserver_fds->list[0];
+#ifdef WINDOWS32
+ if (! open_jobserver_semaphore(cp))
+ {
+ DWORD err = GetLastError();
+ fatal (NILF,_("internal error: unable to open jobserver semaphore `%s': (Error %d: %s)"),
+ cp, err, map_windows32_error_to_string(err));
+ }
+ DB (DB_JOBS, (_("Jobserver client (semaphore %s)\n"), cp));
+#else
if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2)
fatal (NILF,
_("internal error: invalid --jobserver-fds string `%s'"), cp);
DB (DB_JOBS,
(_("Jobserver client (fds %d,%d)\n"), job_fds[0], job_fds[1]));
+#endif
/* The combination of a pipe + !job_slots means we're using the
jobserver. If !job_slots and we don't have a pipe, we can start
error (NILF,
_("warning: -jN forced in submake: disabling jobserver mode."));
+#ifndef WINDOWS32
/* Create a duplicate pipe, that will be closed in the SIGCHLD
handler. If this fails with EBADF, the parent has closed the pipe
on us because it didn't think we were a submake. If so, print a
warning then default to -j1. */
-
else if ((job_rfd = dup (job_fds[0])) < 0)
{
if (errno != EBADF)
_("warning: jobserver unavailable: using -j1. Add `+' to parent make rule."));
job_slots = 1;
}
+#endif
if (job_slots > 0)
{
+#ifdef WINDOWS32
+ free_jobserver_semaphore ();
+#else
close (job_fds[0]);
close (job_fds[1]);
+#endif
job_fds[0] = job_fds[1] = -1;
free (jobserver_fds->list);
free (jobserver_fds);
char *cp;
char c = '+';
+#ifdef WINDOWS32
+ /* sub_proc.c cannot wait for more than MAXIMUM_WAIT_OBJECTS objects
+ * and one of them is the job-server semaphore object. Limit the
+ * number of available job slots to (MAXIMUM_WAIT_OBJECTS - 1). */
+
+ if (job_slots >= MAXIMUM_WAIT_OBJECTS)
+ {
+ job_slots = MAXIMUM_WAIT_OBJECTS - 1;
+ DB (DB_JOBS, (_("Jobserver slots limited to %d\n"), job_slots));
+ }
+
+ if (! create_jobserver_semaphore(job_slots - 1))
+ {
+ DWORD err = GetLastError();
+ fatal (NILF,_("creating jobserver semaphore: (Error %d: %s)"),
+ err, map_windows32_error_to_string(err));
+ }
+#else
if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0)
pfatal_with_name (_("creating jobs pipe"));
+#endif
/* Every make assumes that it always has one job it can run. For the
submakes it's the token they were given by their parent. For the
master_job_slots = job_slots;
+#ifdef WINDOWS32
+ /* We're using the jobserver so set job_slots to 0. */
+ job_slots = 0;
+#else
while (--job_slots)
{
int r;
if (r != 1)
pfatal_with_name (_("init jobserver pipe"));
}
+#endif
/* Fill in the jobserver_fds struct for our children. */
+#ifdef WINDOWS32
+ cp = xmalloc (MAX_PATH + 1);
+ strcpy (cp, get_jobserver_semaphore_name());
+#else
cp = xmalloc ((sizeof ("1024")*2)+1);
sprintf (cp, "%d,%d", job_fds[0], job_fds[1]);
+#endif
jobserver_fds = (struct stringlist *)
xmalloc (sizeof (struct stringlist));
have written all our tokens so do that now. If tokens are left
after any other error code, that's bad. */
+#ifdef WINDOWS32
+ if (has_jobserver_semaphore() && jobserver_tokens)
+#else
if (job_fds[0] != -1 && jobserver_tokens)
+#endif
{
if (status != 2)
error (NILF,
/* Don't write back the "free" token */
while (--jobserver_tokens)
{
+#ifdef WINDOWS32
+ if (! release_jobserver_semaphore())
+ perror_with_name ("release_jobserver_semaphore", "");
+#else
int r;
EINTRLOOP (r, write (job_fds[1], &token, 1));
if (r != 1)
perror_with_name ("write", "");
+#endif
}
}
/* We didn't write one for ourself, so start at 1. */
unsigned int tcnt = 1;
+#ifdef WINDOWS32
+ while (acquire_jobserver_semaphore())
+ ++tcnt;
+#else
/* Close the write side, so the read() won't hang. */
close (job_fds[1]);
while (read (job_fds[0], &token, 1) == 1)
++tcnt;
+#endif
if (tcnt != master_job_slots)
error (NILF,
"INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
tcnt, master_job_slots);
+#ifdef WINDOWS32
+ free_jobserver_semaphore();
+#else
close (job_fds[0]);
+#endif
/* Clean out jobserver_fds so we don't pass this information to any
sub-makes. Also reset job_slots since it will be put on the command
int stdin_data_len));
EXTERN_DECL(long process_file_io, (HANDLE proc));
EXTERN_DECL(void process_cleanup, (HANDLE proc));
-EXTERN_DECL(HANDLE process_wait_for_any, (VOID_DECL));
+EXTERN_DECL(HANDLE process_wait_for_any, (int block, DWORD* pdwWaitStatus));
EXTERN_DECL(void process_register, (HANDLE proc));
EXTERN_DECL(HANDLE process_easy, (char** argv, char** env));
EXTERN_DECL(BOOL process_kill, (HANDLE proc, int signal));
EXTERN_DECL(int process_errcnt, (HANDLE proc));
EXTERN_DECL(void process_pipes, (HANDLE proc, int pipes[3]));
+/* jobserver routines */
+EXTERN_DECL(int open_jobserver_semaphore, (char* name));
+EXTERN_DECL(int create_jobserver_semaphore, (int tokens));
+EXTERN_DECL(void free_jobserver_semaphore, (VOID_DECL));
+EXTERN_DECL(int acquire_jobserver_semaphore, (VOID_DECL));
+EXTERN_DECL(int release_jobserver_semaphore, (VOID_DECL));
+EXTERN_DECL(int has_jobserver_semaphore, (VOID_DECL));
+EXTERN_DECL(char* get_jobserver_semaphore_name, (VOID_DECL));
+EXTERN_DECL(int wait_for_semaphore_or_child_process, (VOID_DECL));
+
#endif
static int proc_index = 0;
static int fake_exits_pending = 0;
+/* Windows jobserver implementation variables */
+static char jobserver_semaphore_name[MAX_PATH + 1];
+static HANDLE jobserver_semaphore = NULL;
+
+/* Open existing jobserver semaphore */
+int open_jobserver_semaphore(char* name)
+{
+ jobserver_semaphore = OpenSemaphore(
+ SEMAPHORE_ALL_ACCESS, // Semaphore access setting
+ FALSE, // Child processes DON'T inherit
+ name); // Semaphore name
+
+ if (jobserver_semaphore == NULL)
+ return 0;
+
+ return 1;
+}
+
+/* Create new jobserver semaphore */
+int create_jobserver_semaphore(int tokens)
+{
+ sprintf(jobserver_semaphore_name, "gmake_semaphore_%d", _getpid());
+
+ jobserver_semaphore = CreateSemaphore(
+ NULL, // Use default security descriptor
+ tokens, // Initial count
+ tokens, // Maximum count
+ jobserver_semaphore_name); // Semaphore name
+
+ if (jobserver_semaphore == NULL)
+ return 0;
+
+ return 1;
+}
+
+/* Close jobserver semaphore */
+void free_jobserver_semaphore()
+{
+ if (jobserver_semaphore != NULL)
+ {
+ CloseHandle(jobserver_semaphore);
+ jobserver_semaphore = NULL;
+ }
+}
+
+/* Decrement semaphore count */
+int acquire_jobserver_semaphore()
+{
+ DWORD dwEvent = WaitForSingleObject(
+ jobserver_semaphore, // Handle to semaphore
+ 0); // DON'T wait on semaphore
+
+ return (dwEvent == WAIT_OBJECT_0);
+}
+
+/* Increment semaphore count */
+int release_jobserver_semaphore()
+{
+ BOOL bResult = ReleaseSemaphore(
+ jobserver_semaphore, // handle to semaphore
+ 1, // increase count by one
+ NULL); // not interested in previous count
+
+ return (bResult);
+}
+
+int has_jobserver_semaphore()
+{
+ return (jobserver_semaphore != NULL);
+}
+
+char* get_jobserver_semaphore_name()
+{
+ return (jobserver_semaphore_name);
+}
+
+/* Wait for either the jobserver semaphore to become signalled or one of our
+ * child processes to terminate.
+ */
+int wait_for_semaphore_or_child_process()
+{
+ HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+ DWORD dwHandleCount = 1;
+ DWORD dwEvent;
+ int i;
+
+ /* Add jobserver semaphore to first slot. */
+ handles[0] = jobserver_semaphore;
+
+ /* Build array of handles to wait for */
+ for (i = 0; i < proc_index; i++)
+ {
+ /* Don't wait on child processes that have already finished */
+ if (fake_exits_pending && proc_array[i]->exit_code)
+ continue;
+
+ handles[dwHandleCount++] = (HANDLE) proc_array[i]->pid;
+ }
+
+ dwEvent = WaitForMultipleObjects(
+ dwHandleCount, // number of objects in array
+ handles, // array of objects
+ FALSE, // wait for any object
+ INFINITE); // wait until object is signalled
+
+ switch(dwEvent)
+ {
+ case WAIT_FAILED:
+ return -1;
+
+ case WAIT_OBJECT_0:
+ /* Indicate that the semaphore was signalled */
+ return 1;
+
+ default:
+ /* Assume that one or more of the child processes terminated. */
+ return 0;
+ }
+}
+
/*
* When a process has been waited for, adjust the wait state
* array so that we don't wait for it again
* Waits for any of the registered child processes to finish.
*/
static sub_process *
-process_wait_for_any_private(void)
+process_wait_for_any_private(int block, DWORD* pdwWaitStatus)
{
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
DWORD retval, which;
/* wait for someone to exit */
if (!fake_exits_pending) {
- retval = WaitForMultipleObjects(proc_index, handles, FALSE, INFINITE);
+ retval = WaitForMultipleObjects(proc_index, handles, FALSE, (block ? INFINITE : 0));
which = retval - WAIT_OBJECT_0;
} else {
fake_exits_pending--;
which = i;
}
+ /* If the pointer is not NULL, set the wait status result variable. */
+ if (pdwWaitStatus)
+ *pdwWaitStatus = retval;
+
/* return pointer to process */
- if (retval != WAIT_FAILED) {
+ if ((retval == WAIT_TIMEOUT) || (retval == WAIT_FAILED)) {
+ return NULL;
+ }
+ else {
sub_process* pproc = proc_array[which];
process_adjust_wait_state(pproc);
return pproc;
- } else
- return NULL;
+ }
}
/*
*/
HANDLE
-process_wait_for_any(void)
+process_wait_for_any(int block, DWORD* pdwWaitStatus)
{
- sub_process* pproc = process_wait_for_any_private();
+ sub_process* pproc = process_wait_for_any_private(block, pdwWaitStatus);
if (!pproc)
return NULL;
DWORD ierr;
if (proc == NULL)
- pproc = process_wait_for_any_private();
+ pproc = process_wait_for_any_private(1, 0);
else
pproc = (sub_process *)proc;
projects / platform / upstream / make.git / commitdiff