News for hackers. Stuff that matters.
Re:Make: Theory and Practice by rspeer on Thursday April 02, 2015 @11:36AM (#9311325)
I'm currently using Make as part of a data-building pipeline. It's nice that it's a build system that doesn't assume my goal is to build a binary or a JS file, and that it's remarkably easy to parallelize.

One deficiency I've come across, which seems to be well-known, is the M:N problem -- where one step takes M input files and has N output files. Make rules seem to expect to have only 1 output, and the workarounds like .SECONDARY prevent some features of Make from working correctly.

I've also seen this limitation in many of the fancy new build systems that get posted here on HN.

Is there a build system, a modification to Make, or anything out there that does keep track of builds with multiple outputs? Not an I/O-guzzling MapReduce framework, please.

Re:Make: Theory and Practice by evmar on Thursday April 02, 2015 @01:24PM (#9312042)
FWIW, my tool Ninja (was just on here again this week here: https://news.ycombinator.com/item?id=9282539 ) was designed to be more or less the same idea as make with some semantic fixes, and that includes supporting multiple outputs.

You can see the brief list of improvements here:

https://martine.github.io/ninja/manual.html#_comparison_to_m...

(Within Ninja this manifests concretely as needing to represent the build graph as a bipartite graph between files and commands. Though I don't know make's internal representation, I imagine the straightforward implementation is as a graph between files and I can imagine why it'd be difficult to make multiple outputs work in that case.)

Re:Make: Theory and Practice by ploxiln on Thursday April 02, 2015 @01:48PM (#9312208)
I really like the minimal and solid design of ninja; I'd agree that if make isn't cutting it, ninja + (your own script to generate all the correct rules) is probably the best way to go.
Re:Make: Theory and Practice by JoshTriplett on Thursday April 02, 2015 @01:52PM (#9312259)
Is there some fundamental reason why the approach used in Ninja couldn't be used to accelerate a substantial subset of Makefiles? If you dropped Make's built-in rules, more complex functions, VPATH, conditionals, and similar items the Ninja manual describes as slowing down Make (all of which are non-portable features of GNU Make), while mostly keeping compatibility with the portable subset of Make, is there some fundamental reason that couldn't be accelerated to the same degree as Ninja?
Re:Make: Theory and Practice by evmar on Thursday April 02, 2015 @03:30PM (#9312633)
No, they should be equivalent. The Ninja manual goes so far as to encourage you to continue using Make if Make is fast enough for you.

However, another way of writing your question is "if you removed the features of make that ninja doesn't have and then optimized the remainder for performance, wouldn't they match?" and that is maybe tautologically true -- that description is roughly what Ninja is, after all.

Because we cared more about performance than other things we maybe were a little crazier about shaving off milliseconds than other systems, so it might be hard to make make fast enough. But (as the Ninja manual suggests) this may only matter for very large (Chrome-sized) projects. You can read a chapter about some of the performance work done on Ninja here: http://www.aosabook.org/en/posa/ninja.html

Re:Make: Theory and Practice by JoshTriplett on Thursday April 02, 2015 @04:40PM (#9313073)
> However, another way of writing your question is "if you removed the features of make that ninja doesn't have and then optimized the remainder for performance, wouldn't they match?" and that is maybe tautologically true -- that description is roughly what Ninja is, after all.

Not exactly. I'm asking if an implementation of the portable subset of Make people actually use (pointedly excluding GNU Make extensions) could be made nearly as fast as Ninja. That would have the advantage of running existing makefiles, as long as those makefiles weren't written specifically for GNU Make.

Re:Make: Theory and Practice by evmar on Friday April 03, 2015 @01:02PM (#9316990)
I think we are maybe talking in circles. :)

When you write "could be made nearly as fast as Ninja", I thought you meant you would change the code of Make or write a new tool. If you don't write a new tool and just use a subset of Make's functionality for your own Makefiles I'd expect those to be faster than your standard Makefiles, sure.

But "existing makefiles" typically use a mixture of GNU make-isms and other things that are not GNU-specific but still slow (e.g. from a skim of the BSD make manual I see lazy variable expansions and control structures). So if you're talking about implementing a subset of Make you're talking about something that's unlikely to be compatible with Makefiles seen in the wild. And then if you're not compatible with Makefiles seen in the wild you've effectively written an incompatible faster subset of Make, which brings us back to what Ninja is. (In case it's not clear, in Chrome's case the same code was used generate Makefiles and Ninja files with some relatively minor output differences -- the tools are that close.)

Perhaps there's some "common" subset of Make that covers some high percentage of build files seen in the wild that could be made faster. That could be valuable to organizations who want faster builds without changing anything. I vaguely recall seeing some commercial software that did this even -- as I recall, their value add was that they had tooling that would figure out how to run your Makefiles in parallel; though Make supports parallel execution, apparently this business found enough customers by just targeting those with underspecified Makefiles that weren't parallel safe and then fixing them!

Anyway, all of this is kinda moot because for 99% of projects Make is plenty fast. I even use Make myself for all my personal projects! In Chrome's case (what we wrote Ninja for) there's so much code that the build files themselves are over ten megabytes of text, so to parse that quickly you're at the level of worrying about avoiding memory allocations in the lexer, which is beyond what most people would care about.

Re:Make: Theory and Practice by JoshTriplett on Friday April 03, 2015 @01:38PM (#9317223)
There are plenty of shell scripts out there that are written for /bin/sh without using bash features; similarly, many makefiles just use the portable subset of make, such as POSIX make. I agree that you'd likely need to write a new tool rather than attempting to optimize GNU make or BSD make. But you wouldn't need to introduce a new syntax; you could just use the POSIX subset of make.

I was partly asking because a fast make-compatible build tool seems easier to switch to, and partly because I wondered how much of Ninja's performance depends on dropping the slow features of make versus adding new capabilities or new syntax.

Re:Make: Theory and Practice by rspeer on Friday April 03, 2015 @12:33AM (#9314416)
Pretty cool. The fact that I'd have to write my own tool to generate the list of dependencies, instead of using pattern rules, is kind of a downer, but--

Okay, now I'm wondering if I could get Make to generate a Ninja file.

Re:Make: Theory and Practice by evmar on Sunday April 05, 2015 @09:35PM (#9326023)
Part of the reason Ninja doesn't support pattern rules is that it would require matching patterns while choosing what to compile. In projects like Chrome (with hundreds of thousands of source files) that can take a while.
Re:Make: Theory and Practice by DSMan195276 on Thursday April 02, 2015 @12:45PM (#9311821)
IIRC, I got around the M:N problem with GNU make by defining a pattern-matching rule to do what I want. For example, I was using yacc, so I did this:

    %.tab.h %.tab.c: %.y
        stuff
Using pattern matching forces make (GNU make) to correctly treat this as one rule which outputs multiple files, instead of the default of it being multiple rules which each output one file. It's not perfect, but it is a simple fix for some of those issues.
Re:Make: Theory and Practice by ploxiln on Thursday April 02, 2015 @01:58PM (#9312299)
That's actually one rule which applies to multiple targets.

If you run without parallelism (the default, -j1), it'll work fine, since make will run the rule for one target, and then when it comes to the second one, make will notice that it's already up-to-date (based on file timestamp).

If you run with -j4 or something, it make will likely run the rule twice, simultaneously. That may or may not be a bad problem depending on how the rule writes the output file.

EDIT: man I must have really rushed reading your post... as you say, this does appear to be a heuristic for GNU Make when it's a pattern rule. clearly make is tricky and I end up learning stuff every time I use make...

Re:Make: Theory and Practice by evmar on Thursday April 02, 2015 @03:33PM (#9312650)
The automake manual has a description of how to get the dependencies right for multiple outputs: http://www.gnu.org/software/automake/manual/html_node/Multip... . (Disclaimer: I'm no expert, and the Make book mentioned elsewhere in this thread may have a better solution.)
Re:Make: Theory and Practice by rspeer on Thursday April 02, 2015 @04:34PM (#9313039)
I think that feature only allows one input. It's 1:N, not M:N.
Re:Make: Theory and Practice by grayclhn on Thursday April 02, 2015 @11:09PM (#9314260)
Maybe, but extending it to an M:1 1:N approach is 95% of the general M:N solution.
Re:Make: Theory and Practice by oavdeev on Thursday April 02, 2015 @01:11PM (#9311961)
Multiple outputs are tricky, what you going to do if you run a step and it somehow produces 2 out of 3 expected outputs? I mean, you need a way to decide whether whole thing failed or not, easiest way is indeed to have dummy targets.

Anyway, take a look at https://github.com/spotify/luigi, it is basically make-like tool geared toward data pipelines. We are experimenting with it for our data pipeline (which is quite sizeable, ~30TB/day gzipped, thousands of files, a bunch of processing steps) and while it lacks some things, especially in the UI, this approach seems to work quite well.

Re:Make: Theory and Practice by stormbrew on Thursday April 02, 2015 @02:25PM (#9312494)
Why would you not want to consider the step failed if it didn't produce all its expected targets?
Re:Make: Theory and Practice by oavdeev on Thursday April 02, 2015 @03:16PM (#9312557)
Yeah, that's my point: if you're happy with this all-or-nothing logic, you can just use dummy target files.

Allowing steps to partially succeed seems like adding quite a lot of complexity, and I'm not sure where it would be beneficial.

Re:Make: Theory and Practice by grayclhn on Thursday April 02, 2015 @11:10PM (#9314268)
Dummy target files don't work if the files are deleted elsewhere --- i.e. not as part of the make pipeline.
Re:Make: Theory and Practice by emelski on Friday April 03, 2015 @12:50AM (#9314447)
You can actually articulate that relationship in GNU make, as long as your outputs can be coerced into a pattern rule (like "%.c %.h: %.y"). Otherwise there's no way to do it that's reliable in the face of both incremental and full builds. There's been discussion of adding syntax to GNU make for this purpose on-and-off over the past several years, but nobody can seem to agree on what the syntax should be.

With Electric Make you can mark the rule as producing multiple outputs by adding "#pragma multi" above the declaration. See http://blog.melski.net/2013/01/01/pragma-multi-and-rules-wit....

Disclaimer: I'm the Chief Architect of Electric Make

Re:Make: Theory and Practice by serve_yay on Thursday April 02, 2015 @03:17PM (#9312567)
> One deficiency I've come across, which seems to be well-known, is the M:N problem -- where one step takes M input files and has N output files. Make rules seem to expect to have only 1 output, and the workarounds like .SECONDARY prevent some features of Make from working correctly.

Jeez, you know, this is the sort of thing that I would hate to get somewhat deep into using make, only to then discover.

I often see hackers lamenting that a plethora of build tools exist instead of everyone just using make, but I'm not so sure that this state of affairs is less preferable. Maybe it's better if the build tool understands some things about the platform it's building for.

Re:Make: Theory and Practice by jgrahamc on Thursday April 02, 2015 @12:22PM (#9311663)
Re:Make: Theory and Practice by oso2k on Thursday April 02, 2015 @12:43PM (#9311806)
Have you read the Make pattern rules examples [0]? There's the specific example of yacc/bison doing something similar to as your describing (at least for 1:N case).

%.tab.c %.tab.h: %.y

        bison -d $<


[0] http://www.gnu.org/savannah-checkouts/gnu/make/manual/html_n...
Re:Make: Theory and Practice by tomn on Thursday April 02, 2015 @12:36PM (#9311759)
I've used SCons for processing audio files recently and it has worked pretty well for me; multiple targets are handled just fine.

I did have one percieved speed problem, but this scons calculating file checksums to see if it needed to re-build targets; this is usually a good thing, but if you're working with large files it might be better to use the MD5-timestamp Decider instead.

Re:Make: Theory and Practice by cafebeen on Thursday April 02, 2015 @01:13PM (#9311971)
I usually create dummy targets for that kind of thing, and then include loops to create dependencies of each of the N on the dummy task. Alternatively, you can create a directory for the output and use that as a target, although you need to ensure the target directory only exists once the M:N task has finished.
Re:Make: Theory and Practice by rspeer on Thursday April 02, 2015 @04:33PM (#9313025)
I'm pretty sure everything you're suggesting here is a workaround that breaks the intended features of Make.

If a multiple-output step fails, I want the outputs to be deleted, and the rest of the dependencies to keep working so I don't have to rebuild everything from scratch. Whatever you're suggesting with dummy targets sounds like it's certainly not going to track the dependencies correctly.

I already know that directories aren't tracked correctly as dependencies.

Re:Make: Theory and Practice by cafebeen on Friday April 03, 2015 @01:51AM (#9314542)
Yeah, you can wrap it up in a script that only produces the expected outputs on a success.

As for workarounds... this is hacker news, is it not?

Re:Make: Theory and Practice by pornel on Thursday April 02, 2015 @12:27PM (#9311698)
Broccoli.js uses directory tree as the primitive

http://www.solitr.com/blog/2014/02/broccoli-first-release/