qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 20:44:40 -07:00
Code Releases Activity
846ee0465b
go/src/runtime/mgc0.h

23 lines
500 B
C
Raw Normal View History

gc: generate garbage collection info for types R=rsc, nigeltao, minux.ma CC=golang-dev https://golang.org/cl/6290043
2012-09-12 10:08:27 -06:00
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
[dev.cc] runtime: bring back mgc0.h This was recorded as an hg mv instead of an hg cp. For now a C version is needed for the Go compiler. TBR=r CC=golang-codereviews https://golang.org/cl/174020043
2014-11-11 16:50:02 -07:00
// Used by cmd/gc.
gc: generate garbage collection info for types R=rsc, nigeltao, minux.ma CC=golang-dev https://golang.org/cl/6290043
2012-09-12 10:08:27 -06:00
enum {
runtime: simpler and faster GC Implement the design described in: https://docs.google.com/document/d/1v4Oqa0WwHunqlb8C3ObL_uNQw3DfSY-ztoA-4wWbKcg/pub Summary of the changes: GC uses "2-bits per word" pointer type info embed directly into bitmap. Scanning of stacks/data/heap is unified. The old spans types go away. Compiler generates "sparse" 4-bits type info for GC (directly for GC bitmap). Linker generates "dense" 2-bits type info for data/bss (the same as stacks use). Summary of results: -1680 lines of code total (-1000+ in mgc0.c only) -25% memory consumption -3-7% binary size -15% GC pause reduction -7% run time reduction LGTM=khr R=golang-codereviews, rsc, christoph, khr CC=golang-codereviews, rlh https://golang.org/cl/106260045
2014-07-29 01:01:02 -06:00
gcBits = 4,
[dev.cc] runtime: bring back mgc0.h This was recorded as an hg mv instead of an hg cp. For now a C version is needed for the Go compiler. TBR=r CC=golang-codereviews https://golang.org/cl/174020043
2014-11-11 16:50:02 -07:00
BitsPerPointer = 2,
BitsDead = 0,
BitsScalar = 1,
BitsPointer = 2,
BitsMask = 3,
PointersPerByte = 8/BitsPerPointer,
runtime: simpler and faster GC Implement the design described in: https://docs.google.com/document/d/1v4Oqa0WwHunqlb8C3ObL_uNQw3DfSY-ztoA-4wWbKcg/pub Summary of the changes: GC uses "2-bits per word" pointer type info embed directly into bitmap. Scanning of stacks/data/heap is unified. The old spans types go away. Compiler generates "sparse" 4-bits type info for GC (directly for GC bitmap). Linker generates "dense" 2-bits type info for data/bss (the same as stacks use). Summary of results: -1680 lines of code total (-1000+ in mgc0.c only) -25% memory consumption -3-7% binary size -15% GC pause reduction -7% run time reduction LGTM=khr R=golang-codereviews, rsc, christoph, khr CC=golang-codereviews, rlh https://golang.org/cl/106260045
2014-07-29 01:01:02 -06:00
insData = 1,
insArray,
insArrayEnd,
insEnd,
runtime: WriteHeapDump dumps the heap to a file. See http://golang.org/s/go13heapdump for the file format. LGTM=rsc R=rsc, bradfitz, dvyukov, khr CC=golang-codereviews https://golang.org/cl/37540043
2014-03-25 16:09:49 -06:00
runtime: cache unrolled GC bitmask Cache unrolled GC bitmask for types up to 64/32K on 64/32-bit systems, this corresponds to up to 4K cached bitmask. Perf builders say that 2% of time is spent in unrollgcproginplace_m/unrollgcprog1 on http benchmark: http://goperfd.appspot.com/log/f42045f45bf61a0da53b724a7c8567824a0ad6c9 LGTM=rsc R=golang-codereviews, rsc CC=golang-codereviews, khr, rlh https://golang.org/cl/122680043
2014-08-24 02:04:51 -06:00
// 64 bytes cover objects of size 1024/512 on 64/32 bits, respectively.
[dev.garbage] cmd/gc, runtime: implement write barriers in terms of writebarrierptr This CL implements the many multiword write barriers by calling writebarrierptr, so that only writebarrierptr needs the actual barrier. In lieu of an actual barrier, writebarrierptr checks that the value being copied is not a small non-zero integer. This is enough to shake out bugs where the barrier is being called when it should not (for non-pointer values). It also found a few tests in sync/atomic that were being too clever. This CL adds a write barrier for the memory moved during the builtin copy function, which I forgot when inserting barriers for Go 1.4. This CL re-enables some write barriers that were disabled for Go 1.4. Those were disabled because it is possible to change the generated code so that they are unnecessary most of the time, but we have not changed the generated code yet. For safety they must be enabled. None of this is terribly efficient. We are aiming for correct first. LGTM=rlh R=rlh CC=golang-codereviews https://golang.org/cl/168770043
2014-10-30 08:16:03 -06:00
MaxGCMask = 65536, // TODO(rsc): change back to 64
runtime: WriteHeapDump dumps the heap to a file. See http://golang.org/s/go13heapdump for the file format. LGTM=rsc R=rsc, bradfitz, dvyukov, khr CC=golang-codereviews https://golang.org/cl/37540043
2014-03-25 16:09:49 -06:00
};
Copy Permalink