private boolean acquireRecyclableLines(int bytes, int align, int offset) {
    while (line < LINES_IN_BLOCK || acquireRecyclableBlock()) {
      line = space.getNextAvailableLine(markTable, line);
      if (line < LINES_IN_BLOCK) {
        int endLine = space.getNextUnavailableLine(markTable, line);
        cursor = recyclableBlock.plus(Extent.fromIntSignExtend(line << LOG_BYTES_IN_LINE));
        limit = recyclableBlock.plus(Extent.fromIntSignExtend(endLine << LOG_BYTES_IN_LINE));
        if (SANITY_CHECK_LINE_MARKS) {
          Address tmp = cursor;
          while (tmp.LT(limit)) {
            if (tmp.loadByte() != (byte) 0) {
              Log.write("cursor: ");
              Log.writeln(cursor);
              Log.write(" limit: ");
              Log.writeln(limit);
              Log.write("current: ");
              Log.write(tmp);
              Log.write("  value: ");
              Log.write(tmp.loadByte());
              Log.write("   line: ");
              Log.write(line);
              Log.write("endline: ");
              Log.write(endLine);
              Log.write("  chunk: ");
              Log.write(Chunk.align(cursor));
              Log.write("     hw: ");
              Log.write(Chunk.getHighWater(Chunk.align(cursor)));
              Log.writeln(" values: ");
              Address tmp2 = cursor;
              while (tmp2.LT(limit)) {
                Log.write(tmp2.loadByte());
                Log.write(" ");
              }
              Log.writeln();
            }
            VM.assertions._assert(tmp.loadByte() == (byte) 0);
            tmp = tmp.plus(1);
          }
        }
        if (VM.VERIFY_ASSERTIONS && bytes <= BYTES_IN_LINE) {
          Address start = alignAllocationNoFill(cursor, align, offset);
          Address end = start.plus(bytes);
          VM.assertions._assert(end.LE(limit));
        }
        VM.memory.zero(cursor, limit.diff(cursor).toWord().toExtent());
        if (VM.VERIFY_ASSERTIONS && Options.verbose.getValue() >= 9) {
          Log.write("Z[");
          Log.write(cursor);
          Log.write("->");
          Log.write(limit);
          Log.writeln("]");
        }

        line = endLine;
        if (VM.VERIFY_ASSERTIONS && copy) VM.assertions._assert(!Block.isDefragSource(cursor));
        return true;
      }
    }
    return false;
  }
Esempio n. 2
0
 /**
  * Zero a region of memory
  *
  * @param start The start of the region to be zeroed (must be 4-byte aligned)
  * @param bytes The number of bytes to be zeroed (must be 4-byte aligned)
  */
 public static void zero(Address start, Extent bytes) throws InlinePragma {
   if (Assert.VERIFY_ASSERTIONS) {
     assertAligned(start);
     assertAligned(bytes);
   }
   if (bytes.GT(Extent.fromIntZeroExtend(SMALL_REGION_THRESHOLD)))
     org.mmtk.vm.Memory.zero(start, bytes);
   else zeroSmall(start, bytes);
 }
 private void zeroBlock(Address block) {
   // FIXME: efficiency check here!
   if (VM.VERIFY_ASSERTIONS)
     VM.assertions._assert(
         block.toWord().and(Word.fromIntSignExtend(BYTES_IN_BLOCK - 1)).isZero());
   VM.memory.zero(block, Extent.fromIntZeroExtend(BYTES_IN_BLOCK));
 }
Esempio n. 4
0
 /**
  * Allows access to an area of virtual memory.
  *
  * @param start the address of the start of the area to be mapped
  * @param size the size, in bytes, of the area to be mapped
  * @return <code>true</code> if successful, otherwise <code>false</code>
  */
 public final boolean munprotect(Address start, int size) {
   return org.jikesrvm.runtime.Memory.mprotect(
       start,
       Extent.fromIntZeroExtend(size),
       org.jikesrvm.runtime.Memory.PROT_READ
           | org.jikesrvm.runtime.Memory.PROT_WRITE
           | org.jikesrvm.runtime.Memory.PROT_EXEC);
 }
Esempio n. 5
0
 /**
  * Demand zero mmaps an area of virtual memory.
  *
  * @param start the address of the start of the area to be mapped
  * @param size the size, in bytes, of the area to be mapped
  * @return 0 if successful, otherwise the system errno
  */
 public final int dzmmap(Address start, int size) {
   Address result = org.jikesrvm.runtime.Memory.dzmmap(start, Extent.fromIntZeroExtend(size));
   if (result.EQ(start)) return 0;
   if (result.GT(Address.fromIntZeroExtend(127))) {
     VM.sysWrite("demand zero mmap with MAP_FIXED on ", start);
     VM.sysWriteln(" returned some other address", result);
     VM.sysFail("mmap with MAP_FIXED has unexpected behavior");
   }
   return result.toInt();
 }
Esempio n. 6
0
 /**
  * Protects access to an area of virtual memory.
  *
  * @param start the address of the start of the area to be mapped
  * @param size the size, in bytes, of the area to be mapped
  * @return <code>true</code> if successful, otherwise <code>false</code>
  */
 public final boolean mprotect(Address start, int size) {
   return org.jikesrvm.runtime.Memory.mprotect(
       start, Extent.fromIntZeroExtend(size), org.jikesrvm.runtime.Memory.PROT_NONE);
 }
Esempio n. 7
0
 private static final void assertAligned(Extent value) {
   assertAligned(value.toWord());
 }