diff --git a/.gitignore b/.gitignore index 5a1f3db3..d48dd2b6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ -*~ *.exe +*~ +/gen/lib a.out diff --git a/README.md b/README.md index 402ae9ca..705463db 100644 --- a/README.md +++ b/README.md @@ -298,6 +298,10 @@ that all the way through to C code generation and testing. - [Puffs the Language](./doc/puffs-the-language.md) - Puffs the Library (TODO) +Measurements: + +- [Binary Size](./doc/binary-size.md) + # Related Work @@ -443,11 +447,6 @@ it is unsurprising that they don't depend on the C compiler (clang or gcc) used to run the test harness. -## Code Size - -TODO. - - ## Roadmap Short term: @@ -514,4 +513,4 @@ owned by Google. --- -Updated on July 2017. +Updated on August 2017. diff --git a/cmd/puffs-genlib-c/main.go b/cmd/puffs-genlib-c/main.go new file mode 100644 index 00000000..0eeb5079 --- /dev/null +++ b/cmd/puffs-genlib-c/main.go @@ -0,0 +1,122 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +// puffs-genlib-c builds C software libraries. +package main + +import ( + "flag" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" +) + +var ( + dstdirFlag = flag.String("dstdir", "", "directory containing the object files ") + srcdirFlag = flag.String("srcdir", "", "directory containing the C source files") +) + +func main() { + if err := main1(); err != nil { + os.Stderr.WriteString(err.Error() + "\n") + os.Exit(1) + } +} + +func main1() error { + flag.Parse() + if *dstdirFlag == "" { + return fmt.Errorf("empty -dstdir flag") + } + if *srcdirFlag == "" { + return fmt.Errorf("empty -srcdir flag") + } + args := flag.Args() + + for _, cc := range []string{"clang", "gcc"} { + for _, dynamism := range []string{"static", "dynamic"} { + outDir := filepath.Join(*dstdirFlag, cc+"-"+dynamism) + if err := os.MkdirAll(outDir, 0755); err != nil { + return err + } + if err := genObj(outDir, cc, dynamism, args); err != nil { + return err + } + if err := genLib(outDir, cc, dynamism, args); err != nil { + return err + } + } + } + return nil +} + +// TODO: are these extensions correct for non-Linux? +var ( + objExtensions = map[string]string{ + "dynamic": ".lo", + "static": ".o", + } + libExtensions = map[string]string{ + "dynamic": ".so", + "static": ".a", + } +) + +func genObj(outDir string, cc string, dynamism string, filenames []string) error { + for _, filename := range filenames { + in := filepath.Join(*srcdirFlag, filename+".c") + out := outFilename(outDir, dynamism, filename) + + args := []string(nil) + args = append(args, "-O3", "-std=c99") + if dynamism == "dynamic" { + args = append(args, "-fPIC", "-DPIC") + } + args = append(args, "-c", "-o", out, in) + + cmd := exec.Command(cc, args...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + return err + } + fmt.Printf("genlib: %s\n", out) + } + return nil +} + +func genLib(outDir string, cc string, dynamism string, filenames []string) error { + args := []string(nil) + switch dynamism { + case "dynamic": + // TODO: add a "-Wl,-soname,libpuffs.so.1.2.3" argument? + args = append(args, "-shared", "-fPIC", "-o") + case "static": + cc = "ar" + args = append(args, "rc") + } + out := filepath.Join(outDir, "libpuffs"+libExtensions[dynamism]) + args = append(args, out) + + for _, filename := range filenames { + args = append(args, outFilename(outDir, dynamism, filename)) + } + + cmd := exec.Command(cc, args...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + return err + } + fmt.Printf("genlib: %s\n", out) + return nil +} + +func outFilename(outDir string, dynamism string, filename string) string { + filename = strings.Replace(filename, "/", "-", -1) + filename = strings.Replace(filename, "\\", "-", -1) + filename = filepath.Join(outDir, filename+objExtensions[dynamism]) + return filename +} diff --git a/cmd/puffs/gen.go b/cmd/puffs/gen.go index a9193026..6b95ad24 100644 --- a/cmd/puffs/gen.go +++ b/cmd/puffs/gen.go @@ -21,7 +21,10 @@ import ( "github.com/google/puffs/lang/token" ) -func doGen(puffsRoot string, args []string) error { +func doGen(puffsRoot string, args []string) error { return doGenGenlib(puffsRoot, args, false) } +func doGenlib(puffsRoot string, args []string) error { return doGenGenlib(puffsRoot, args, true) } + +func doGenGenlib(puffsRoot string, args []string, genlib bool) error { flags := flag.NewFlagSet("gen", flag.ExitOnError) langsFlag := flags.String("langs", langsDefault, langsUsage) if err := flags.Parse(args); err != nil { @@ -36,36 +39,48 @@ func doGen(puffsRoot string, args []string) error { args = []string{"std/..."} } + affected := []string(nil) for _, arg := range args { recursive := strings.HasSuffix(arg, "/...") if recursive { arg = arg[:len(arg)-4] } - if err := gen(puffsRoot, arg, langs, recursive); err != nil { + var err error + affected, err = gen(affected, puffsRoot, arg, langs, recursive) + if err != nil { + return err + } + } + + if genlib { + if err := genlibAffected(puffsRoot, langs, affected); err != nil { return err } } return nil } -func gen(puffsRoot, dirname string, langs []string, recursive bool) error { +func gen(affected []string, puffsRoot, dirname string, langs []string, recursive bool) (retAffected []string, retErr error) { filenames, dirnames, err := listDir(puffsRoot, dirname, recursive) if err != nil { - return err + return nil, err } if len(filenames) > 0 { if err := genDir(puffsRoot, dirname, filenames, langs); err != nil { - return err + return nil, err } + affected = append(affected, dirname) } if len(dirnames) > 0 { for _, d := range dirnames { - if err := gen(puffsRoot, dirname+"/"+d, langs, recursive); err != nil { - return err + var err error + affected, err = gen(affected, puffsRoot, dirname+"/"+d, langs, recursive) + if err != nil { + return nil, err } } } - return nil + return affected, nil } func genDir(puffsRoot string, dirname string, filenames []string, langs []string) error { @@ -156,3 +171,20 @@ func genFile(puffsRoot string, dirname string, lang string, out []byte) error { fmt.Println("gen wrote: ", outFilename) return nil } + +func genlibAffected(puffsRoot string, langs []string, affected []string) error { + for _, lang := range langs { + command := "puffs-genlib-" + lang + args := []string(nil) + args = append(args, "-dstdir", filepath.Join(puffsRoot, "gen", "lib", lang)) + args = append(args, "-srcdir", filepath.Join(puffsRoot, "gen", lang)) + args = append(args, affected...) + cmd := exec.Command(command, args...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + return err + } + } + return nil +} diff --git a/cmd/puffs/main.go b/cmd/puffs/main.go index 23340eaa..adb0e6a3 100644 --- a/cmd/puffs/main.go +++ b/cmd/puffs/main.go @@ -21,6 +21,7 @@ var commands = []struct { }{ {"bench", doBench}, {"gen", doGen}, + {"genlib", doGenlib}, {"test", doTest}, } @@ -35,6 +36,7 @@ The commands are: bench benchmark packages gen generate code for packages and dependencies + genlib generate software libraries test test packages `) } diff --git a/cmd/puffs/test.go b/cmd/puffs/test.go index 6de3a1a7..65a55c56 100644 --- a/cmd/puffs/test.go +++ b/cmd/puffs/test.go @@ -51,7 +51,7 @@ func doBenchTest(puffsRoot string, args []string, bench bool) error { } // Ensure that we are testing the latest version of the generated code. - if err := gen(puffsRoot, arg, langs, recursive); err != nil { + if _, err := gen(nil, puffsRoot, arg, langs, recursive); err != nil { return err } @@ -103,7 +103,8 @@ func benchTestDir(puffsRoot string, dirname string, langs []string, cmdArgs []st for _, lang := range langs { command := "puffs-test-" + lang - args := append([]string(nil), cmdArgs...) + args := []string(nil) + args = append(args, cmdArgs...) args = append(args, filepath.Join(puffsRoot, "test", lang, filepath.FromSlash(dirname))) cmd := exec.Command(command, args...) cmd.Stdout = os.Stdout diff --git a/doc/binary-size.md b/doc/binary-size.md new file mode 100644 index 00000000..4dfac9c1 --- /dev/null +++ b/doc/binary-size.md @@ -0,0 +1,45 @@ +# Binary Size + +*Preliminary* measurements of `puffs genlib` libraries' binary size, on x86_64 +are below. Lower is better. + + clang-dynamic: + -rwxr-x--- 1 nigeltao eng 35235 Aug 10 14:59 libpuffs.so + -rw-r----- 1 nigeltao eng 18592 Aug 10 14:59 std-flate.lo + -rw-r----- 1 nigeltao eng 10080 Aug 10 14:59 std-gif.lo + + clang-static: + -rw-r----- 1 nigeltao eng 29576 Aug 10 14:59 libpuffs.a + -rw-r----- 1 nigeltao eng 18360 Aug 10 14:59 std-flate.o + -rw-r----- 1 nigeltao eng 9968 Aug 10 14:59 std-gif.o + + gcc-dynamic: + -rwxr-x--- 1 nigeltao eng 39210 Aug 10 14:59 libpuffs.so + -rw-r----- 1 nigeltao eng 21448 Aug 10 14:59 std-flate.lo + -rw-r----- 1 nigeltao eng 12000 Aug 10 14:59 std-gif.lo + + gcc-static: + -rw-r----- 1 nigeltao eng 34152 Aug 10 14:59 libpuffs.a + -rw-r----- 1 nigeltao eng 21200 Aug 10 14:59 std-flate.o + -rw-r----- 1 nigeltao eng 11704 Aug 10 14:59 std-gif.o + + +## Comparison + +Below are some standard C libraries shipped as part of Ubuntu 14.04 LTS +"Trusty". The numbers aren't directly comparable, as these libraries have a +richer API, especially in providing an encoder and not just a decoder. Still, +it is a reference point for e.g. Puffs flate vs libz and Puffs gif vs libgif. + + dynamic: + -rw-r--r-- 1 root root 100728 May 13 2013 /lib/x86_64-linux-gnu/libz.so.1.2.8 + -rw-r--r-- 1 root root 36000 Dec 16 2013 /usr/lib/x86_64-linux-gnu/libgif.so.4.1.6 + + static: + -rw-r--r-- 1 root root 142346 May 13 2013 /usr/lib/x86_64-linux-gnu/libz.a + -rw-r--r-- 1 root root 51850 Dec 16 2013 /usr/lib/x86_64-linux-gnu/libgif.a + + +--- + +Updated on August 2017. diff --git a/example/library/library.c b/example/library/library.c new file mode 100644 index 00000000..09af931e --- /dev/null +++ b/example/library/library.c @@ -0,0 +1,68 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +/* +library exercises the software libraries built by `puffs genlib`. + +To exercise the static library: + +$cc -static -I../../.. library.c ../../gen/lib/c/$cc-static/libpuffs.a +./a.out +rm -f a.out + +To exercise the dynamic library: + +$cc -I../../.. library.c -L../../gen/lib/c/$cc-dynamic -lpuffs +LD_LIBRARY_PATH=../../gen/lib/c/$cc-dynamic ./a.out +rm -f a.out + +for a C compiler $cc, such as clang or gcc. +*/ + +#include + +#include "puffs/gen/h/std/flate.h" + +#define DST_BUFFER_SIZE (1024 * 1024) + +size_t lgtm_len = 20; + +uint8_t lgtm_ptr[] = { + 0xf3, 0xc9, 0xcf, 0xcf, 0x2e, 0x56, 0x48, 0xcf, 0xcf, 0x4f, + 0x51, 0x28, 0xc9, 0x57, 0xc8, 0x4d, 0xd5, 0xe3, 0x02, 0x00, +}; + +// ignore_return_value suppresses errors from -Wall -Werror. +static void ignore_return_value(int ignored) {} + +static const char* decode(puffs_flate_decoder* dec) { + uint8_t dst_buffer[DST_BUFFER_SIZE]; + puffs_base_buf1 dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE}; + puffs_base_buf1 src = { + .ptr = lgtm_ptr, .len = lgtm_len, .wi = lgtm_len, .closed = true}; + puffs_base_writer1 dst_writer = {.buf = &dst}; + puffs_base_reader1 src_reader = {.buf = &src}; + + puffs_flate_status s = + puffs_flate_decoder_decode(dec, dst_writer, src_reader); + if (s) { + return puffs_flate_status_string(s); + } + ignore_return_value(write(1, dst.ptr, dst.wi)); + return NULL; +} + +int main(int argc, char** argv) { + puffs_flate_decoder dec; + puffs_flate_decoder_constructor(&dec, PUFFS_VERSION, 0); + const char* status_msg = decode(&dec); + puffs_flate_decoder_destructor(&dec); + + int status = 0; + if (status_msg) { + status = 1; + ignore_return_value(write(2, status_msg, strnlen(status_msg, 4095))); + ignore_return_value(write(2, "\n", 1)); + } + return status; +}