github.com/rothwerx/packer@v0.9.0/post-processor/compress/benchmark.go (about)

     1  // +build ignore
     2  
     3  package main
     4  
     5  import (
     6  	"compress/flate"
     7  	"compress/gzip"
     8  	"fmt"
     9  	"io"
    10  	"io/ioutil"
    11  	"os"
    12  	"runtime"
    13  	"testing"
    14  
    15  	"github.com/biogo/hts/bgzf"
    16  	"github.com/klauspost/pgzip"
    17  	"github.com/pierrec/lz4"
    18  )
    19  
    20  type Compressor struct {
    21  	r  *os.File
    22  	w  *os.File
    23  	sr int64
    24  	sw int64
    25  }
    26  
    27  func (c *Compressor) Close() error {
    28  	var err error
    29  
    30  	fi, _ := c.w.Stat()
    31  	c.sw = fi.Size()
    32  	if err = c.w.Close(); err != nil {
    33  		return err
    34  	}
    35  
    36  	fi, _ = c.r.Stat()
    37  	c.sr = fi.Size()
    38  	if err = c.r.Close(); err != nil {
    39  		return err
    40  	}
    41  
    42  	return nil
    43  }
    44  
    45  func NewCompressor(src, dst string) (*Compressor, error) {
    46  	r, err := os.Open(src)
    47  	if err != nil {
    48  		return nil, err
    49  	}
    50  
    51  	w, err := os.Create(dst)
    52  	if err != nil {
    53  		r.Close()
    54  		return nil, err
    55  	}
    56  
    57  	c := &Compressor{r: r, w: w}
    58  	return c, nil
    59  }
    60  
    61  func main() {
    62  
    63  	runtime.GOMAXPROCS(runtime.NumCPU())
    64  
    65  	var resw testing.BenchmarkResult
    66  	var resr testing.BenchmarkResult
    67  
    68  	c, err := NewCompressor("/tmp/image.r", "/tmp/image.w")
    69  	if err != nil {
    70  		panic(err)
    71  	}
    72  	resw = testing.Benchmark(c.BenchmarkGZIPWriter)
    73  	c.w.Seek(0, 0)
    74  	resr = testing.Benchmark(c.BenchmarkGZIPReader)
    75  	c.Close()
    76  	fmt.Printf("gzip:\twriter %s\treader %s\tsize %d\n", resw.T.String(), resr.T.String(), c.sw)
    77  
    78  	c, err = NewCompressor("/tmp/image.r", "/tmp/image.w")
    79  	if err != nil {
    80  		panic(err)
    81  	}
    82  	resw = testing.Benchmark(c.BenchmarkBGZFWriter)
    83  	c.w.Seek(0, 0)
    84  	resr = testing.Benchmark(c.BenchmarkBGZFReader)
    85  	c.Close()
    86  	fmt.Printf("bgzf:\twriter %s\treader %s\tsize %d\n", resw.T.String(), resr.T.String(), c.sw)
    87  
    88  	c, err = NewCompressor("/tmp/image.r", "/tmp/image.w")
    89  	if err != nil {
    90  		panic(err)
    91  	}
    92  	resw = testing.Benchmark(c.BenchmarkPGZIPWriter)
    93  	c.w.Seek(0, 0)
    94  	resr = testing.Benchmark(c.BenchmarkPGZIPReader)
    95  	c.Close()
    96  	fmt.Printf("pgzip:\twriter %s\treader %s\tsize %d\n", resw.T.String(), resr.T.String(), c.sw)
    97  
    98  	c, err = NewCompressor("/tmp/image.r", "/tmp/image.w")
    99  	if err != nil {
   100  		panic(err)
   101  	}
   102  	resw = testing.Benchmark(c.BenchmarkLZ4Writer)
   103  	c.w.Seek(0, 0)
   104  	resr = testing.Benchmark(c.BenchmarkLZ4Reader)
   105  	c.Close()
   106  	fmt.Printf("lz4:\twriter %s\treader %s\tsize %d\n", resw.T.String(), resr.T.String(), c.sw)
   107  
   108  }
   109  
   110  func (c *Compressor) BenchmarkGZIPWriter(b *testing.B) {
   111  	cw, _ := gzip.NewWriterLevel(c.w, flate.BestSpeed)
   112  	b.ResetTimer()
   113  
   114  	_, err := io.Copy(cw, c.r)
   115  	if err != nil {
   116  		b.Fatal(err)
   117  	}
   118  	cw.Close()
   119  	c.w.Sync()
   120  }
   121  
   122  func (c *Compressor) BenchmarkGZIPReader(b *testing.B) {
   123  	cr, _ := gzip.NewReader(c.w)
   124  	b.ResetTimer()
   125  
   126  	_, err := io.Copy(ioutil.Discard, cr)
   127  	if err != nil {
   128  		b.Fatal(err)
   129  	}
   130  }
   131  
   132  func (c *Compressor) BenchmarkBGZFWriter(b *testing.B) {
   133  	cw, _ := bgzf.NewWriterLevel(c.w, flate.BestSpeed, runtime.NumCPU())
   134  	b.ResetTimer()
   135  
   136  	_, err := io.Copy(cw, c.r)
   137  	if err != nil {
   138  		b.Fatal(err)
   139  	}
   140  	c.w.Sync()
   141  }
   142  
   143  func (c *Compressor) BenchmarkBGZFReader(b *testing.B) {
   144  	cr, _ := bgzf.NewReader(c.w, 0)
   145  	b.ResetTimer()
   146  
   147  	_, err := io.Copy(ioutil.Discard, cr)
   148  	if err != nil {
   149  		b.Fatal(err)
   150  	}
   151  }
   152  
   153  func (c *Compressor) BenchmarkPGZIPWriter(b *testing.B) {
   154  	cw, _ := pgzip.NewWriterLevel(c.w, flate.BestSpeed)
   155  	b.ResetTimer()
   156  
   157  	_, err := io.Copy(cw, c.r)
   158  	if err != nil {
   159  		b.Fatal(err)
   160  	}
   161  	cw.Close()
   162  	c.w.Sync()
   163  }
   164  
   165  func (c *Compressor) BenchmarkPGZIPReader(b *testing.B) {
   166  	cr, _ := pgzip.NewReader(c.w)
   167  	b.ResetTimer()
   168  
   169  	_, err := io.Copy(ioutil.Discard, cr)
   170  	if err != nil {
   171  		b.Fatal(err)
   172  	}
   173  }
   174  
   175  func (c *Compressor) BenchmarkLZ4Writer(b *testing.B) {
   176  	cw := lz4.NewWriter(c.w)
   177  	//	cw.Header.HighCompression = true
   178  	cw.Header.NoChecksum = true
   179  	b.ResetTimer()
   180  
   181  	_, err := io.Copy(cw, c.r)
   182  	if err != nil {
   183  		b.Fatal(err)
   184  	}
   185  	cw.Close()
   186  	c.w.Sync()
   187  }
   188  
   189  func (c *Compressor) BenchmarkLZ4Reader(b *testing.B) {
   190  	cr := lz4.NewReader(c.w)
   191  	b.ResetTimer()
   192  
   193  	_, err := io.Copy(ioutil.Discard, cr)
   194  	if err != nil {
   195  		b.Fatal(err)
   196  	}
   197  }