parallelwriter

type BufferedWriter ¶

type BufferedWriter struct {
	// contains filtered or unexported fields
}

func NewBufferedWriter(w WriteFlusher, bufferSize int) *BufferedWriter

func (b *BufferedWriter) Close() error

func (b *BufferedWriter) Flush() error

func (b *BufferedWriter) Write(buf []byte) (int, error)

type PipelinedFlushWriter ¶

type PipelinedFlushWriter struct {
	// contains filtered or unexported fields
}

PipelinedFlushWriter is a writer that serialises and batches parallel writes, similar to Writer, but with two additional properties:

1. Flush is performed after every Write.
2. Flush and Write are pipelined, so that a Flush may occur in parallel with a Write, but Writes are serialised, and Flushes are serialised.

This behaviour is particularly useful for write-ahead logs, where the caller wants to ensure writes are flushed to disk, but also wants to do many writes in parallel for high total throughput.

func NewPipelinedFlushWriter(wf WriteFlusher) *PipelinedFlushWriter

func (w *PipelinedFlushWriter) Write(buf []byte) (int, error)

type WriteFlusher ¶

type WriteFlusher interface {
	io.Writer
	Flush() error
}

func NopFlusher(w io.Writer) WriteFlusher

type Writer ¶

type Writer struct {
	// contains filtered or unexported fields
}

Writer serialises and batches concurrent writes, to minimise Write calls to the underlying io.Writer. This is useful when the underlying io.Writer has properties that make each Write expensive, such as sending across a network and waiting for an ack, or flushing after every write. If your io.Writer does not have this property, you should instead synchronize using a sync.Mutex.

func NewWriter(w io.Writer) *Writer

func (w *Writer) Write(b []byte) (int, error)