scanobject(b, gcw)

		// Flush background scan work credit.
		if gcw.heapScanWork >= gcCreditSlack {
			gcController.heapScanWork.Add(gcw.heapScanWork)
			workFlushed += gcw.heapScanWork
			gcw.heapScanWork = 0
		}
	}

	// Unlike gcDrain, there's no need to flush remaining work
	// here because this never flushes to bgScanCredit and
	// gcw.dispose will flush any remaining work to scanWork.

	systemstack(freeStackSpans)

	// Ensure all mcaches are flushed. Each P will flush its own
	// mcache before allocating, but idle Ps may not. Since this
	// is necessary to sweep all spans, we need to ensure all
	// mcaches are flushed before we start the next GC cycle.
	//
	// While we're here, flush the page cache for idle Ps to avoid
	// having pages get stuck on them. These pages are hidden from

	str := strings.Repeat("x", 1<<10)
	bs := []byte(str)
	for i := 0; i < b.N; i++ {
		bw := NewWriter(io.Discard)
		bw.Flush()
		bw.WriteByte('a')
		bw.Flush()
		bw.WriteRune('B')
		bw.Flush()
		bw.Write(bs)
		bw.Flush()
		bw.WriteString(str)
		bw.Flush()
	}
}

func BenchmarkWriterFlush(b *testing.B) {
	b.ReportAllocs()
	bw := NewWriter(io.Discard)

	tx.Flush(&knftables.Set{
		Name: clusterIPsSet,
	})
	tx.Flush(&knftables.Map{
		Name: firewallIPsMap,
	})
	tx.Flush(&knftables.Map{
		Name: noEndpointServicesMap,
	})
	tx.Flush(&knftables.Map{
		Name: noEndpointNodePortsMap,
	})
	tx.Flush(&knftables.Map{
		Name: serviceIPsMap,
	})
	tx.Flush(&knftables.Map{
		Name: serviceNodePortsMap,

	FF1                           = 0x2000
	FFDLY                         = 0x2000
	FLUSHBAND                     = 0x40
	FLUSHLOW                      = 0x8
	FLUSHO                        = 0x100000
	FLUSHR                        = 0x1
	FLUSHRW                       = 0x3
	FLUSHW                        = 0x2
	F_CLOSEM                      = 0xa
	F_DUP2FD                      = 0xe
	F_DUPFD                       = 0x0

		t.Errorf("got body %q; expected %q", bodyBytes, expected)
	}
}

type mockFlusher struct {
	http.ResponseWriter
	flushed bool
}

func (m *mockFlusher) Flush() {
	m.flushed = true
}

type wrappedRW struct {
	http.ResponseWriter
}

func (w *wrappedRW) Unwrap() http.ResponseWriter {
	return w.ResponseWriter
}

		// both the h1 and h2 Server's write buffers. For h1,
		// sendfile is used, though, forcing a header flush at
		// the io.Copy. http2 doesn't do a header flush so
		// buffers all 11 bytes and then adds its own
		// Content-Length. To prevent the Server's
		// Content-Length and test ServeFile only, flush here.
		w.(Flusher).Flush()
	}))
	resp, err := cst.c.Get(cst.ts.URL)
	if err != nil {
		t.Fatal(err)
	}

            if (response.getHttpStatusCode() == 200) {
                logger.info("Flushed config files.");
            } else {
                logger.warn("Failed to flush config files.");
            }
        } catch (final Exception e) {
            logger.warn("Failed to flush config files.", e);
        }
    }

	FF1                           = 0x2000
	FFDLY                         = 0x2000
	FLUSHBAND                     = 0x40
	FLUSHLOW                      = 0x8
	FLUSHO                        = 0x100000
	FLUSHR                        = 0x1
	FLUSHRW                       = 0x3
	FLUSHW                        = 0x2
	F_CLOSEM                      = 0xa
	F_DUP2FD                      = 0xe
	F_DUPFD                       = 0x0

	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBaseOptions(b *testing.B) {
	v := BaseOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)