Missing feature

classic Classic list List threaded Threaded
2 messages Options
Reply | Threaded
Open this post in threaded view
|

Missing feature

Jason Wessel
Attached is a patch against the latest CVS to add the function
updatecache.

Attached is also an example of a batching compiler script.

The idea here is to use a rule to collect a series of files together in
a variable and pass them all to the compiler at once.

I ran into the problem that the standard make 3.80 was not able to
update the time stamps of targets that did not have a direct dependency
of a rule.  I would like to get this feature added to gnu make or learn
of another way to do the same thing if it is possible another way.

The example from the example_batch is as follows.

% touch b.h ; make all
***building***: Batched a.c b.c c.c
g++ a.c b.c c.c
Building TARGET dummy_exe with: a.o b.o c.o
% touch b.h ; make all
***building***: Batched b.c c.c
g++ b.c c.c
% touch b.h ; make all
***building***: Batched b.c c.c
g++ b.c c.c
Building TARGET dummy_exe with: a.o b.o c.o
% touch b.h ; make all
***building***: Batched b.c c.c
g++ b.c c.c
% touch b.h ; make all
***building***: Batched b.c c.c
g++ b.c c.c
Building TARGET dummy_exe with: a.o b.o c.o


You can see that without the patch my dummy_exe is only built every
other time because the dependencies time stamps are not able to be
updated after the build rule has been processed.

Thanks,
Jason.
 <<func_updatecache.patch>>

_______________________________________________
Bug-make mailing list
[hidden email]
http://lists.gnu.org/mailman/listinfo/bug-make

example_batch.tar.gz (1K) Download Attachment
func_updatecache.patch (4K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: Missing feature

Ted Stern
On 17 Jun 2005 at 17:06 UTC-0700, Jason Wessel wrote:
> Attached is a patch against the latest CVS to add the function
> updatecache.
>
> Attached is also an example of a batching compiler script.
>
> The idea here is to use a rule to collect a series of files together
> in a variable and pass them all to the compiler at once.

I do something like this when building a library.  There is an
additional complication for me in that a list of 10K objects in a
directory hierarchy exceeds the character length that can be passed to
a shell command.  So I use a recursive gmake function to build a file
containing each item in the list on a separate line, then I use the
~10K line file as input for the command using the unix command
'xargs'.  See the man page for that function for more details on
usage.

I'm attaching my MAKE_LONG_LIST function below.  Use it in a target
rule, e.g., as follows:

LISTFILE := yourtarget.list

yourtarget: $(the_very_long_list)
      $(call MAKE_LONG_LIST,$(LISTFILE),$(the_very_long_list))
      xargs $(YOURCOMMAND) $@ < $(LISTFILE)

>
> I ran into the problem that the standard make 3.80 was not able to
> update the time stamps of targets that did not have a direct
> dependency of a rule.  I would like to get this feature added to gnu
> make or learn of another way to do the same thing if it is possible
> another way.

What you want to do is slightly different.

Try chaining the dependencies a little.  Your dummy target will be
built first.  When it comes time to run the .o rules, those files will
already be updated and their rules won't be run.

    SRCS := a.cc b.cc c.cc
    OBJS := $(SRCS:.cc=.o)

    .PHONY: dummy

    dummy: $(SRCS)
          $(CXX) $(CXXFLAGS) $^

    $(OBJS): dummy.foo

Ted
--
 Ted Stern                                 Applications Group
 Cray Inc.                               office: 206-701-2182
 411 First Avenue South, Suite 600         cell: 206-383-1049
 Seattle, WA 98104-2860                     FAX: 206-701-2500

 Frango ut patefaciam -- I break so that I may reveal
 (The Paleontological Society motto, equally apropos for debugging)


#
# MAKE_LONG_LIST:
#
# MAKE function to be called when a long variable list needs to be
# put into a file with one item on each line.
# Two arguments:
# $(1) = list name
# $(2) = MAKE variable to put into list
#
# The resulting list can be used in combination with xargs to get
# around shell command-line character-length restrictions.
#
# The current hack is encapsulated in a separate included Makefile
# to hide the confusing recursive function.
#
# RECURSIVE version is requires GNU make-3.80 or higher, but is shorter and
# will handle any size list.
#

# CALC:
# Math helper function -- Use shell to do simple operations.
# Relies on ksh/bash $(( )) syntax.
# If you don't like this or need something more portable, change to
# CALC = $(shell echo "$(1)" | bc)
CALC = $(shell echo $$(($(1))))

nextindx = $(call CALC,$(3)+1)
nextword = $(word $(nextindx),$(2))
nextlist = $(wordlist $(nextindx),$(words $(2)),$(2))

# ADD_TO_LIST:
# A recursive function definition to handle iteration
# ARG 1 = filename to contain list, one entry per line
# ARG 2 = variable containing a very long list
# ARG 3 = Increment
define ADD_TO_LIST
        @printf "%s\n" $(wordlist 1,$(3),$(2)) >> $(1)
        $(if $(nextword),$(call ADD_TO_LIST,$(1),$(nextlist),$(3)),@echo)
endef

# Actual MAKE_LONG_LIST definition is a wrapper around the recursive call.
# Note that the list file is first cleared out using Bourne/ksh/bash syntax.
# I just arbitrarily set the iteration size to 500, but you can make it
# smaller if the system environment length is still too large.
define MAKE_LONG_LIST
        : > $(1)
        $(call ADD_TO_LIST,$(1),$(2),500)
endef

_______________________________________________
Bug-make mailing list
[hidden email]
http://lists.gnu.org/mailman/listinfo/bug-make