Lines Matching refs:bit
10 // by 1-bit bitmaps in which 0 means uninteresting and 1 means live pointer
12 // the low bit: 1<<0, 1<<1, and so on.
20 // That is, the byte at address start-1 holds the 2-bit entries for the four words
24 // In each 2-bit entry, the lower bit holds the same information as in the 1-bit
26 // The meaning of the high bit depends on the position of the word being described
27 // in its allocated object. In the first word, the high bit is the GC ``marked'' bit.
28 // In the second word, the high bit is the GC ``checkmarked'' bit (see below).
29 // In the third and later words, the high bit indicates that the object is still
30 // being described. In these words, if a bit pair with a high bit 0 is encountered,
31 // the low bit can also be assumed to be 0, and the object description is over.
35 // The 2-bit entries are split when written into the byte, so that the top half
37 // This form allows a copy from the 1-bit to the 4-bit form to keep the
41 // has no live pointer bit set and is (depending on position), not marked,
52 // In checkmark mode, in the heap bitmap, the high bit of the 2-bit entry
53 // for the second word of the object holds the checkmark bit.
54 // When not in checkmark mode, this bit is set to 1.
56 // The smallest possible allocation is 8 bytes. On a 32-bit machine, that
58 // checkmark bit. On a 64-bit machine, however, the 8-byte allocation is
59 // just one word, so the second bit pair is not available for encoding the
62 // must be a pointer, so the type bit in the first word is not actually needed.
63 // It is still used in general, except in checkmark the type bit is repurposed
64 // as the checkmark bit and then reinitialized (to 1) as the type bit when
278 // isMarked reports whether the heap bits have the marked bit set.
284 // setMarked sets the marked bit in the heap bits, atomically.
294 // setMarkedNonAtomic sets the marked bit in the heap bits, non-atomically.
328 // At least a 4-word object. Check scan bit (aka marked bit) in third word.
335 // isCheckmarked reports whether the heap bits have the checkmarked bit set.
337 // checkmark bit varies by size.
344 // so we know that the initial word's 2-bit pair
345 // and the second word's 2-bit pair are in the
350 // setCheckmarked sets the checkmarked bit.
352 // checkmark bit varies by size.
502 // The ptrSize == 8 is a compile-time constant false on 32-bit and eliminates this code entirely.
504 // Checkmark bit is type bit, bottom bit of every 2-bit entry.
505 // Only possible on 64-bit system, since minimum size is 8.
506 // Must clear type bit (checkmark bit) of every word.
507 // The type bit is the lower of every two-bit pair.
526 // The ptrSize == 8 is a compile-time constant false on 32-bit and eliminates this code entirely.
528 // Checkmark bit is type bit, bottom bit of every 2-bit entry.
529 // Only possible on 64-bit system, since minimum size is 8.
530 // Must clear type bit (checkmark bit) of every word.
531 // The type bit is the lower of every two-bit pair.
546 // For non-free objects, heapBitsSweepSpan turns off the marked bit.
553 // Consider mark bits in all four 2-bit entries of each bitmap byte.
560 // That lets heapBitsSetType avoid an atomic update to set the pointer bit
587 // Mark bit is in first word of each object.
588 // Each object starts at bit 0 of a heap bitmap byte.
604 // Mark bit is in first word of each object,
656 // which can be setting the mark bit in the leading 2-bit entry
684 throw("heapBitsSetType: pointer bit missing")
691 ptrmask := typ.gcdata // start of 1-bit pointer mask (or GC program, handled below)
695 // This is called out as a special case primarily for 32-bit systems,
696 // so that on 32-bit systems the code below can assume all objects
701 // On 64-bit, that means the actual object must be two pointers,
703 // On 32-bit, however, this is the 8-byte block, the smallest one.
742 // Copy from 1-bit ptrmask into 2-bit bitmap.
743 // The basic approach is to use a single uintptr as a bit buffer,
769 // as the 1-bit case. Nothing above could have encountered
775 // by running the GC program to create a 1-bit pointer mask
777 // This doesn't catch bugs shared between the 1-bit and 4-bit
802 // The 1-bit ptrmasks are sized to contain only bits for
919 // and must not be set. In all following words, we want to set the mark bit
920 // as a signal that the object continues to the next 2-bit entry in the bitmap.
939 // not with its mark bit. Since there is only one allocation
997 // be larger than the bit width of b.
1001 // Almost as fast path: track bit count and refill from pbits.
1163 throw("heapBitsSetTypeGCProg: unexpected bit count")
1229 // progToPointerMask returns the 1-bit pointer mask output by the GC program prog.
1259 // If size == 1, dst is a 1-bit pointer mask laid out moving forward from dst.
1260 // If size == 2, dst is the 2-bit heap bitmap, and writes move backward
1264 // runGCProg returns the number of 1- or 2-bit entries written to memory.
1368 // the pattern to a bit buffer holding at most 7 bits (a partial byte)
1396 // We started with the whole bit output buffer,
1407 // One bit being repeated.
1408 // If the bit is 1, make the pattern all 1s.
1409 // If the bit is 0, the pattern is already all 0s,
1437 // Add pattern to bit buffer and flush bit buffer, c/npattern times.
1460 // Add final fragment to bit buffer.
1483 // The bits are rotating through the bit buffer.
1506 // The bits are rotating through the bit buffer.
1544 // above to set the marker in every bit written and
