8 |
9 | *Fac* is the Latin imperative form of the verb *facere*, which means
10 | "to do" or "to make." Thus when you type *fac* you are saying "Do
11 | it!" or "Make it!" which is basically what you mean.
12 |
13 | There are a number of English words that derive from *facere*:
14 |
15 | * Factory
16 | * Facile or Facilitate
17 | * Manufacture
18 | * Facsimile ("make similar")
19 | * Fact (which originally meant something more like "feat")
20 | * -ify, the suffix that shows up in "clarify", "ossify" or "liquify"
21 | meaning "to make" or "to become"
22 |
--------------------------------------------------------------------------------
/tests/getting-started.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | set -ev
4 |
5 | echo $0
6 |
7 | # This test ensures that the getting-started tutorial actually works
8 | # right.
9 |
10 | rm -rf $0.dir
11 | mkdir $0.dir
12 | cd $0.dir
13 |
14 | cp ${FAC:-../../fac} fac
15 |
16 | if ! which pdflatex; then
17 | echo there is no latex
18 | exit 137
19 | fi
20 |
21 | if ! test -f /usr/share/dict/words; then
22 | echo there is no /usr/share/dict/words
23 | exit 137
24 | fi
25 |
26 | # Setting the PATH in the following ensures that we call our
27 | # newly-built fac, rather than one that is already installed.
28 | PATH=`pwd`:$PATH python3 ../getting-started.py ../../web/getting-started.md
29 |
--------------------------------------------------------------------------------
/tests/dependency-cycle.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | set -ev
4 |
5 | echo $0
6 |
7 | # This test ensures that we can count builds properly to figure out if
8 | # we have built everything correctly.
9 |
10 | rm -rf $0.dir
11 | mkdir $0.dir
12 | cd $0.dir
13 |
14 | cat > top.fac <
12 |
13 | * Automatically tracks build dependencies in a way that is independent
14 | of programming language. You are only required to specify the
15 | minimum of dependencies for each rule (which is often an empty set),
16 | and fac works out the rest for you. If you fail to specify
17 | dependencies, fac should still build successfully if you use it
18 | repeatedly.
19 |
20 | * Parallel building.
21 |
22 | * You are forced to write your configuration in a language of your own
23 | choice. (Or conversely, you are not forced to use a language of
24 | *my* choice, much less a custom-built language that I developed.)
25 |
26 | * Integrates with git, to keep you from forgetting to `git add` a file
27 | that is needed for the build.
28 |
29 | ## How does it work?
30 |
31 | - Fac uses ptrace to track every system call your build command makes.
32 | Thus we can see precisely which files are read, and which files are
33 | modified.
34 |
35 | - Fac has an extremely simple declarative
36 | [file format](documentation.html). There are no variables, no
37 | functions, no macros. Just data. This could be a problem for
38 | larger projects if you were forced to write these files by hand.
39 | But in most large projects you will just write a script to generate
40 | these files.
41 |
42 | - You write your "build" script as a program (in the language of your
43 | choice) that creates a `.fac` file. This script is run (and
44 | re-run) using the same dependency-tracking mechanism that is used to
45 | for an ordinary build. Thus, you can get away with writing a simple
46 | but inefficient script, since it will only seldom be run. (Unlike,
47 | e.g. `scons` which has to rerun your `SConstruct` python file on
48 | every build.)
49 |
50 | - If your build rules depend on the operating system, or the system
51 | environment, your "configure" script is the same program (in the
52 | language of your choice) that creates a `.fac` file. Or perhaps
53 | it provides input to the script that actually creates the `.fac`
54 | file.
55 |
56 | For a lengthier introduction and motivation for fac, see
57 | [Introducing fac](introducing-fac.html).
58 |
--------------------------------------------------------------------------------
/bench/dependentchains.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python3
2 |
3 | import os, hashlib, time, sys, datetime
4 |
5 | name='dependent-chain'
6 |
7 | allowed_chars = 'abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ'
8 |
9 | def hashid(n):
10 | m = hashlib.sha1()
11 | m.update(str(n).encode('utf-8'))
12 | name = ''
13 | for i in m.digest()[:24]:
14 | name += allowed_chars[i % len(allowed_chars)]
15 | return name+('_%d' % n)
16 |
17 | def open_and_gitadd(fname):
18 | f = open(fname, 'w')
19 | assert(not os.system('git add '+fname))
20 | return f
21 |
22 | def create_bench(n):
23 | sconsf = open_and_gitadd('SConstruct')
24 | facf = open_and_gitadd('top.fac')
25 | open_and_gitadd('Tupfile.ini')
26 | sconsf.write("""
27 | env = Environment(CPPPATH=['.'])
28 | """)
29 | facf.write("""
30 | | gcc -o final.exe final.c
31 | > final.exe
32 | < final.c
33 | < %s-generated.h
34 |
35 | """ % hashid(n))
36 | f = open_and_gitadd('final.c')
37 | f.write("""
38 | #include "%s-generated.h"
39 | #include
6 |
7 | This document will define the security model for fac. Although this
8 | may seem excessive given the context, I believe every piece of
9 | software should have a security model describing what it should and
10 | should not do, and what an adversary should be able to control.
11 |
12 | Fac's security model is pretty simple, since it is controlled by a
13 | repository and typically has no interaction with the network.
14 | Nevertheless there is value in making this explicit.
15 |
16 | ## Data flow
17 |
18 | A threat model starts with a data flow diagram, indicating where data
19 | moves in the application. For fac this is very simple, and I will not
20 | bother creating a visual model. Information comes into fac through
21 | the on-disk representation of a git repository. This information
22 | determines what fac does, which will necesarily involve running
23 | arbitrary commands as requested by the configuration stored in the
24 | repository. This will in turn produce files on disk.
25 |
26 | ## Threats
27 |
28 | ### Other users
29 |
30 | *A user without write permission in the repository or the `$PATH` (or
31 | a superuser-like capability) should be unable to affect the commands
32 | run by fac.* This does not mean that any commands run by fac must be
33 | secure, which would be impossible, since fac can run arbitrary
34 | insecure programs. But said user should not be able to cause fac to
35 | run the "wrong" command.
36 |
37 | This could happen either through a tempfile vulnerability, or through
38 | allowing other users to modify our processes. Fac should be safe from
39 | this kind of error due to not using tempfiles, except (in some
40 | circumstances) in the repository directory, which is not writeable by
41 | these attackers.
42 |
43 | ### Privilege escalation
44 |
45 | *A user running fac in their own repository should be unable to
46 | accomplish any action that they could not accomplish without the use
47 | of fac.* This means that if fac were to be implemented as an SUID
48 | program, it would need to be secure. Since it is not so implemented,
49 | I don't see how it could lead to privilege escalation.
50 |
51 | On MacOS, it is possible fac will need to be SUID root, in which case
52 | this could become a significant risk.
53 |
54 | ### Network access
55 |
56 | *Fac should not make or receive any network connections, unless such
57 | connections are explicitly created by a configured rule.* If you
58 | create a rule such as
59 |
60 | | git clone https://github.com/droundy/fac
61 |
62 | then of course fac will access the network, but absent any such rule,
63 | fac should not be accessing the network. No phoning home, for
64 | instance. This should essentially come for free, since we didn't
65 | program this in.
66 |
67 | ## Conclusion
68 |
69 | Because fac is designed to run arbitrary code, there is relatively
70 | little we need worry about. e.g. execution of arbitrary code due to a
71 | malformed input file is a non-issue, since a well-formed input file
72 | also enables the execution of arbitrary code. The only two real
73 | questions are privilege escalation and interference by other users
74 | (most likely due to tempfile vulnerabilities). We believe these risks
75 | are adequately addressed by the current implementation of fac.
76 |
--------------------------------------------------------------------------------
/configure.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python3
2 |
3 | from __future__ import print_function
4 | import string, os, sys, platform, subprocess
5 |
6 | myplatform = sys.platform
7 | if myplatform == 'linux2':
8 | myplatform = 'linux'
9 |
10 | def is_in_path(program):
11 | """ Does the program exist in the PATH? """
12 | def is_exe(fpath):
13 | return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
14 | fpath, fname = os.path.split(program)
15 | if fpath:
16 | return is_exe(program)
17 | else:
18 | for path in os.environ["PATH"].split(os.pathsep):
19 | path = path.strip('"')
20 | exe_file = os.path.join(path, program)
21 | if is_exe(exe_file):
22 | return True
23 | return False
24 |
25 | def can_run(cmd):
26 | print('# trying', cmd, file=sys.stdout)
27 | try:
28 | subprocess.check_output(cmd, shell=True)
29 | return True
30 | except Exception as e:
31 | print("# error: ", e)
32 | return False
33 |
34 | have_sass = can_run('sass -h')
35 | have_help2man = can_run('help2man --help')
36 |
37 | if have_help2man:
38 | print('''
39 | | help2man --no-info ./fac > fac.1
40 | < fac''')
41 | else:
42 | print("# no help2man, so we won't build the man page")
43 |
44 | if have_sass:
45 | print('''
46 | | sass -I. web/style.scss web/style.css
47 | > web/style.css
48 | C .sass-cache
49 | ''')
50 | else:
51 | print("# no sass, so we won't build style.css")
52 |
53 | def cargo_cmd(cmd, inps, outs):
54 | print('\n| {}'.format(cmd))
55 | for i in inps:
56 | print("< {}".format(i))
57 | for o in outs:
58 | print("> {}".format(o))
59 | if 'cargo-test-output.log' not in outs:
60 | print('c .log')
61 | print('''c ~
62 | c #
63 | C .nfs
64 | c ~
65 | c .fac
66 | c .tum
67 | c .pyc
68 | c .o
69 | c fac.exe
70 | c __pycache__
71 | c .gcda
72 | c .gcno
73 | c .gcov
74 | c src/version.rs
75 | c Cargo.lock
76 | c fac
77 | c fac-afl
78 | c -pak
79 | c .deb
80 | c .1
81 | C doc-pak
82 | C bench
83 | C tests
84 | C bugs
85 | C web
86 | C target
87 | C bigbro
88 | ''')
89 |
90 | if is_in_path('cargo'):
91 | cargo_cmd("cargo build --features strict && mv target/debug/fac debug-fac", [],
92 | ["debug-fac"])
93 | # cargo_cmd("cargo test --features strict > cargo-test-output.log",
94 | # [], ['cargo-test-output.log'])
95 | cargo_cmd("cargo doc --no-deps && cp -a target/doc web/", [],
96 | ["web/doc/fac/index.html"])
97 | cargo_cmd("cargo build --release && mv target/release/fac fac", [],
98 | ["fac"])
99 | print("""
100 | # make copies of the executables, so that if cargo fails we will still
101 | # have an old version of the executable, since cargo deletes output on
102 | # failure.
103 | | cp debug-fac backup-debug-fac
104 | < debug-fac
105 | > backup-debug-fac
106 |
107 | | cp fac backup-fac
108 | < fac
109 | > backup-fac""")
110 | else:
111 | print('# no cargo, so cannot build using rust')
112 |
113 | try:
114 | targets = subprocess.check_output('rustup show', shell=True)
115 | if b'x86_64-pc-windows-gnu' in targets:
116 | cargo_cmd("cargo build --features strict --target x86_64-pc-windows-gnu", [], [])
117 | except:
118 | print('# no rust for windows')
119 |
--------------------------------------------------------------------------------
/tests/getting-started.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python3
2 |
3 | import sys, os, re, subprocess
4 |
5 | if sys.version_info < (3,5):
6 | print('Please run this script with python 3.5 or newer:', sys.version)
7 | exit(137)
8 |
9 | runre = re.compile(r'\[run\]: # \((.+)\)')
10 | shellre = re.compile(r'^ \$ (.+)')
11 | filere = re.compile(r'##### (.+)')
12 | verbre = re.compile(r'^ (.*)')
13 | time_remaining_re = re.compile(r'^Build time remaining: ')
14 |
15 | with open(sys.argv[1]) as f:
16 | for line in f:
17 | isfile = filere.findall(line)
18 | isshell = shellre.findall(line)
19 | if len(isfile) > 0:
20 | with open(isfile[0], 'w') as newf:
21 | for line in f:
22 | isverb = verbre.findall(line)
23 | if len(isverb) == 0:
24 | break
25 | newf.write(isverb[0])
26 | newf.write('\n')
27 | print(isfile[0], ':', isverb[0])
28 | elif len(isshell) > 0:
29 | print('shell :', isshell[0])
30 | tocheck = True
31 | if isshell[0][-len('# fails'):] == '# fails':
32 | tocheck = False
33 | print('SHOULD FAIL!')
34 | isshell[0] = isshell[0][:-len('# fails')]
35 | ret = subprocess.run(isshell, shell=True,
36 | stderr=subprocess.STDOUT,
37 | check=tocheck,
38 | stdout=subprocess.PIPE)
39 | if not tocheck and ret.returncode == 0:
40 | print("DID NOT FAIL!!!")
41 | exit(1)
42 | print('output:', ret.stdout)
43 | output = ret.stdout
44 | for outline in output.decode('utf-8').split('\n'):
45 | # The time_remaining_re bit is needed to skip the
46 | # "Build time remaining:" lines that get printed every
47 | # once in a while. These are irregular, which is why
48 | # we need to do this.
49 | if len(outline)>0 and not time_remaining_re.match(outline):
50 | print('output:', outline)
51 | expectedline = f.readline()
52 | if len(verbre.findall(expectedline)) == 0:
53 | print('unexpected output from:', isshell[0])
54 | print('output is', outline)
55 | exit(1)
56 | if expectedline in [' ...', ' ...\n']:
57 | print('I expected random output.')
58 | break
59 | expected = verbre.findall(expectedline)[0]
60 | expected = expected.replace('.', r'\.')
61 | expected = expected.replace('*', r'\*')
62 | expected = expected.replace(r'\.\.\.', '.*')
63 | expected = expected.replace('[', r'\[')
64 | expected = expected.replace(']', r'\]')
65 | expected = expected.replace('(', r'\(')
66 | expected = expected.replace(')', r'\)')
67 | if not re.compile(expected).match(outline):
68 | print('I expected:', expected)
69 | print('but instead I got:', outline)
70 | exit(1)
71 | else:
72 | print('input', line.strip())
73 |
--------------------------------------------------------------------------------
/bench/plot-benchmark.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python3
2 | from __future__ import print_function
3 |
4 | import os, sys
5 |
6 | import matplotlib
7 | matplotlib.use('Agg')
8 | import matplotlib.pyplot as plt
9 | import numpy as np
10 |
11 | import cats
12 | import hierarchy
13 | import dependentchains
14 | import sleepy
15 | import independent
16 |
17 | #matplotlib.rc('font', size='16.0')
18 |
19 | datadir = os.getcwd()+'/data/'
20 | modules = [dependentchains, cats, hierarchy, sleepy, independent]
21 |
22 | allcolors = ['r','b','g','k','c','y','m', 'r']
23 | allpatterns = ['o-', 's:', '*-.', 'x--', '.-', '<-', '>-', 'v-']
24 |
25 | tool_patterns = {}
26 | fslabels, fshandles = [], []
27 | toollabels, toolhandles = [], []
28 |
29 | mod = None
30 | for m in modules:
31 | if m.name == sys.argv[1]:
32 | mod = m
33 | if mod is None:
34 | print("Invalid mod: ", sys.argv[1])
35 | exit(1)
36 |
37 | verb = sys.argv[2]
38 | if verb not in mod.verbs:
39 | print("Invalid verb: ", sys.argv[2])
40 | exit(1)
41 |
42 | dates = os.listdir(datadir)
43 | dates.sort()
44 | date = dates[-1]
45 | # os.chdir(datadir+date+'/'+mod.name)
46 | print('date', date, mod.name)
47 |
48 | plt.figure(figsize=(6,4.3))
49 | plt.title('%s %s on %s' % (verb, mod.name, date))
50 | have_handled = {}
51 |
52 | num_fs = len(os.listdir(datadir+date+'/'+mod.name+'/fac -j4'))
53 |
54 | tools = os.listdir(datadir+date+'/'+mod.name)
55 | tools.sort()
56 | for tool in tools:
57 | if not tool in tool_patterns:
58 | tool_patterns[tool] = allpatterns[0]
59 | allpatterns = allpatterns[1:]
60 | if num_fs == 1:
61 | mycolor = allcolors[0]
62 | allcolors = allcolors[1:]
63 | toollabels.append(tool)
64 | toolhandles.append(plt.Line2D((0,1),(0,0), marker=tool_patterns[tool][0],
65 | linestyle=tool_patterns[tool][1:], color='k'))
66 | for fs in os.listdir(datadir+date+'/'+mod.name+'/'+tool):
67 | if num_fs > 1 and not fs in fs_colors:
68 | mycolor = allcolors[0]
69 | allcolors = allcolors[1:]
70 | fslabels.append(fs)
71 | fshandles.append(plt.Line2D((0,1),(0,0), color=fs_colors[fs], linewidth=3))
72 | data = np.loadtxt(datadir+date+'/'+mod.name+'/'+tool+'/'+fs+'/'+verb+'.txt')
73 | # The folowing few lines handles the case where we
74 | # have run the benchmark a few times, and have
75 | # redundant data. We sort it, and then replace all
76 | # the points with a given N with the average of all
77 | # the measurements (from that date).
78 | if len(data.shape) == 2:
79 | for n in data[:,0]:
80 | ind = data[:,0] == n
81 | data[ind,1] = np.mean(data[ind,1])
82 | data = np.sort(np.vstack({tuple(row) for row in data}), axis=0) # remove duplicate lines
83 | if num_fs > 1:
84 | mylabel = '%s on %s' % (tool, fs)
85 | else:
86 | mylabel = tool
87 | plt.loglog(data[:,0], data[:,1]/data[:,0],
88 | tool_patterns[tool],
89 | color=mycolor,
90 | label=mylabel)
91 | plt.gca().grid(True)
92 | plt.xlabel('$N$')
93 | plt.ylabel('$t/N$ (s)')
94 | if num_fs > 1:
95 | plt.legend(fshandles+toolhandles, fslabels+toollabels, loc='best', frameon=False)
96 | else:
97 | plt.legend(loc='best', frameon=False)
98 |
99 | plt.tight_layout()
100 | # plt.savefig('../web/%s-%s.pdf' % (mod.name, verb))
101 | plt.savefig('../web/%s-%s.svg' % (mod.name, verb), dpi=60)
102 | # plt.savefig('../web/%s-%s.png' % (mod.name, verb), dpi=100)
103 |
--------------------------------------------------------------------------------
/src/git.rs:
--------------------------------------------------------------------------------
1 | //! Support interaction with git
2 |
3 | use std;
4 |
5 | /// Go to the top level of the git repository (typically the one
6 | /// containing a `.git` directory).
7 | pub fn go_to_top() -> std::path::PathBuf {
8 | let mut output = std::process::Command::new("git")
9 | .args(&["rev-parse", "--show-toplevel"])
10 | .output()
11 | .expect("Error calling git rev-parse --show-toplevel");
12 | // #ifdef _WIN32
13 | // if (strlen(buf) > 2 && buf[0] == '/' && buf[2] == '/') {
14 | // // this is a workaround for a broken git included in msys2
15 | // // which returns paths like /c/Users/username...
16 | // buf[0] = buf[1];
17 | // buf[1] = ':';
18 | // }
19 | // #endif
20 |
21 | if !output.status.success() {
22 | println!("Error identifying git top.");
23 | let newlen = output.stderr.len()-1;
24 | output.stderr.truncate(newlen);
25 | println!(" {}", bytes_to_path(&output.stderr).display());
26 | std::process::exit(1);
27 | }
28 | let newlen = output.stdout.len()-1;
29 | output.stdout.truncate(newlen);
30 | let p = bytes_to_path(&output.stdout);
31 | std::env::set_current_dir(&p).unwrap();
32 | p
33 | }
34 |
35 | /// Location of the .git directory
36 | pub fn git_dir() -> std::path::PathBuf {
37 | let mut output = std::process::Command::new("git")
38 | .args(&["rev-parse", "--git-dir"])
39 | .output()
40 | .expect("Error calling git rev-parse --git-dir");
41 | // #ifdef _WIN32
42 | // if (strlen(buf) > 2 && buf[0] == '/' && buf[2] == '/') {
43 | // // this is a workaround for a broken git included in msys2
44 | // // which returns paths like /c/Users/username...
45 | // buf[0] = buf[1];
46 | // buf[1] = ':';
47 | // }
48 | // #endif
49 |
50 | if !output.status.success() {
51 | println!("Error identifying git-dir.");
52 | let newlen = output.stderr.len()-1;
53 | output.stderr.truncate(newlen);
54 | println!(" {}", bytes_to_path(&output.stderr).display());
55 | std::process::exit(1);
56 | }
57 | let newlen = output.stdout.len()-1;
58 | output.stdout.truncate(newlen);
59 | bytes_to_path(&output.stdout)
60 | }
61 |
62 | /// Find out what files are in git.
63 | pub fn ls_files() -> std::collections::HashSet41 | Optional rules can be helpful for rules (often autogenerated) that 42 | might be slow or require dependencies that not all users will 43 | have. They can be convenient for scripts that define a whole slew 44 | of rules in a facfile, and which don't want to determine which of 45 | these are needed for the actual build. Or for something like 46 | documentation, which only some users will want to actually build. 47 |
48 | 49 | 3. Output specifications beginning with `"> "` followed by the name of 50 | the file that is output. There is no escaping performed, and only 51 | newlines and null characters are disallowed in the file name. 52 | There is little need to specify the output for rules, since fac 53 | can determine this automatically. The only reason to specify 54 | output is so that on the very first build a user can request that 55 | we build only the specified rule. 56 | 57 | 4. Input specifications beginning with `"< "` followed by the name of 58 | the file that is required. You only need specify inputs when they 59 | are generated files. Even then, you need only specify the inputs 60 | if you wish to have the build succeed on the first attempt. 61 | 62 | 5. Dependency output specifications beginning with `"M "` followed by 63 | the name of the deps file that is generated by the command. This 64 | is designed for compilers which have the ability to track 65 | dependencies and output a `Makefile` fragment documenting those 66 | dependencies. This is implemented for two reasons. Firstly, by 67 | relying on the compiler for dependency tracking, fac can run more 68 | quickly than if it tracks file accesses itself. Secondly, it makes 69 | fac more useful on platforms (currently Windows and Mac OS) where 70 | it is unable to track dependencies. *This feature is only 71 | available in the version of fac implemented in rust.* 72 | 73 | 6. There are two ways to specify "cache" files. A cache file is a 74 | file that may be either read or written by a given command, but 75 | doesn't affect the output and not itself an output. One nice 76 | example is the ".pyc" files sometimes generated when you run a 77 | python program. One python command may produce a .pyc file, and 78 | another may read it (if they both use the same module), but that 79 | does not mean that there is a dependency between those two 80 | commands. You can specify a cache suffix (such as `.pyc`) using a 81 | `"c "` line, or you can specify a cache prefix (such as 82 | `~/.ccache`) using a capitalized `"C "` line. The latter can be 83 | helpful if you find that your software is being rebuilt needlessly 84 | due to some cache file being modified. 85 | -------------------------------------------------------------------------------- /bench/hierarchy.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python3 2 | 3 | import os, hashlib, time, numpy, sys, datetime 4 | 5 | name = 'hierarchy' 6 | 7 | def make_name(i): 8 | path = '.' 9 | digits = '%d' % i 10 | for d in digits: 11 | path = path+'/number-'+d 12 | return path[2:]+('_%d' % i) 13 | 14 | allowed_chars = 'abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ' 15 | 16 | def hashid(n): 17 | m = hashlib.sha1() 18 | m.update(str(n).encode('utf-8')) 19 | name = '' 20 | for i in m.digest()[:24]: 21 | name += allowed_chars[i % len(allowed_chars)] 22 | return name+('_%d' % n) 23 | 24 | def hash_integer(n): 25 | m = hashlib.sha1() 26 | m.update(str(n).encode('utf-8')) 27 | name = 0 28 | for i in m.digest()[:8]: 29 | name = name*256 + i 30 | return abs(name) 31 | 32 | def open_and_gitadd(fname): 33 | f = open(fname, 'w') 34 | assert(not os.system('git add '+fname)) 35 | return f 36 | 37 | def create_bench(N): 38 | sconsf = open_and_gitadd('SConstruct') 39 | facf = open_and_gitadd('top.fac') 40 | open_and_gitadd('Tupfile.ini') 41 | sconsf.write(""" 42 | env = Environment(CPPPATH=['.']) 43 | """) 44 | for i in range(N): 45 | if i > 9: 46 | os.makedirs(os.path.dirname(make_name(i)), exist_ok=True) 47 | cname = make_name(i) + '.c' 48 | hname = make_name(i) + '.h' 49 | includes = '' 50 | funcs = '' 51 | for xx in [i+ii for ii in range(10)]: 52 | nhere = hash_integer(xx) % N 53 | includes += '#include "%s.h"\n' % make_name(nhere) 54 | funcs += ' %s();\n' % hashid(nhere) 55 | facf.write(""" 56 | # %d 57 | | gcc -I. -O2 -c -o %s.o %s.c 58 | > %s.o 59 | """ % (i, make_name(i), make_name(i), make_name(i))) 60 | sconsf.write(""" 61 | env.Object('%s.c') 62 | """ % make_name(i)) 63 | f = open_and_gitadd(make_name(i)+'.c') 64 | f.write('\n') 65 | f.write("""/* c file %s */ 66 | 67 | %s#include "%s" 68 | 69 | #include