1 /*
   2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 import java.util.Objects;
  24 import sun.misc.VM;
  25 
  26 /**
  27  * @test
  28  * @bug 8068730 
  29  * @summary tests that VM.getgetNanoTimeAdjustment() works as expected.
  30  * @run main GetNanoTimeAdjustment
  31  * @author danielfuchs
  32  */
  33 public class GetNanoTimeAdjustment {
  34 
  35     static final int MILLIS_IN_SECOND = 1000;
  36     static final int NANOS_IN_MILLI = 1000_000;
  37     static final int NANOS_IN_MICRO = 1000;
  38     static final int NANOS_IN_SECOND = 1000_000_000;
  39 
  40     static final boolean verbose = true;
  41 
  42     static final class TestAssertException extends RuntimeException {
  43         TestAssertException(String msg) { super(msg); }
  44     }
  45 
  46     private static void assertEquals(long expected, long received, String msg) {
  47         if (expected != received) {
  48             throw new TestAssertException("Unexpected result for " + msg
  49                     + ".\n\texpected: " + expected
  50                     +  "\n\tactual:   " + received);
  51         } else if (verbose) {
  52             System.out.println("Got expected " + msg + ": " + received);
  53         }
  54     }
  55 
  56     private static void assertEquals(Object expected, Object received, String msg) {
  57         if (!Objects.equals(expected, received)) {
  58             throw new TestAssertException("Unexpected result for " + msg
  59                     + ".\n\texpected: " + expected
  60                     +  "\n\tactual:   " + received);
  61         } else if (verbose) {
  62             System.out.println("Got expected " + msg + ": " + received);
  63         }
  64     }
  65 
  66     static final long MAX_OFFSET = 0x0100000000L;
  67     static final long MIN_OFFSET = -MAX_OFFSET;
  68     static enum Answer {
  69         YES,   // isOffLimit = YES:   we must get -1
  70         NO,    // isOffLimit = NO:    we must not not get -1
  71         MAYBE  // isOffLimit = MAYBE: we might get -1 or a valid adjustment.
  72     };
  73     static long distance(long one, long two) {
  74         return one > two ? Math.subtractExact(one, two)
  75                 : Math.subtractExact(two, one);
  76     }
  77 
  78 
  79     static Answer isOffLimits(long before, long after, long offset) {
  80         long relativeDistanceBefore = distance(before, offset);
  81         long relativeDistanceAfter  = distance(after, offset);
  82         if (relativeDistanceBefore >= MAX_OFFSET && relativeDistanceAfter >= MAX_OFFSET) {
  83             return Answer.YES;
  84         }
  85         if (relativeDistanceBefore < MAX_OFFSET && relativeDistanceAfter < MAX_OFFSET) {
  86             if (relativeDistanceBefore == 0 || relativeDistanceAfter == 0) {
  87                 return Answer.MAYBE; // unlucky case where
  88             }
  89             return Answer.NO;
  90         }
  91         return Answer.MAYBE;
  92     }
  93 
  94     static void testWithOffset(String name, long offset) {
  95         System.out.println("Testing with offset: " + name);
  96         long beforeMillis = System.currentTimeMillis();
  97         long adjustment = VM.getNanoTimeAdjustment(offset);
  98         long afterMillis = System.currentTimeMillis();
  99 
 100         if (offset >= beforeMillis/MILLIS_IN_SECOND
 101                 && offset <= afterMillis/MILLIS_IN_SECOND) {
 102             if (adjustment == -1) {
 103                 // it's possible that we have fallen in the unlucky case
 104                 // where -1 was the genuine result. let's go backward a bit.
 105                 offset = offset - 10;
 106                 beforeMillis = System.currentTimeMillis();
 107                 adjustment = VM.getNanoTimeAdjustment(offset);
 108                 afterMillis = System.currentTimeMillis();
 109                 if (adjustment == -1) {
 110                     throw new RuntimeException(name + ": VM says " + offset
 111                             + " secs is too far off, "
 112                             + " when time in seconds is in ["
 113                             + beforeMillis/MILLIS_IN_SECOND + ", "
 114                             + afterMillis/MILLIS_IN_SECOND
 115                             + "]");
 116                 }
 117             }
 118         }
 119 
 120         Answer isOffLimit = isOffLimits(beforeMillis/MILLIS_IN_SECOND,
 121                 afterMillis/MILLIS_IN_SECOND, offset);
 122         switch (isOffLimit) {
 123             case YES:
 124                 if (adjustment != -1) {
 125                     throw new RuntimeException(name
 126                         + ": VM should have returned -1 for "
 127                         + offset
 128                         + " when time in seconds is in ["
 129                         + beforeMillis/MILLIS_IN_SECOND + ", "
 130                         + afterMillis/MILLIS_IN_SECOND + "]");
 131                 }
 132                 System.out.println("Got expected exception value: " + adjustment);
 133                 break;
 134             case NO:
 135                 if (adjustment == -1) {
 136                     throw new RuntimeException(name
 137                             + "VM says "  + offset
 138                             + " secs is too far off, "
 139                             + " when time in seconds is in ["
 140                             + beforeMillis/MILLIS_IN_SECOND + ", "
 141                             + afterMillis/MILLIS_IN_SECOND
 142                             + "]");
 143                 }
 144                 break;
 145             case MAYBE:
 146                 System.out.println("Adjustment: " + adjustment);
 147                 System.out.println("Can't assert for -1 with offset "
 148                         + offset + "(" + name + ")"
 149                         + " when time in seconds is in ["
 150                         + beforeMillis/MILLIS_IN_SECOND + ", "
 151                         + afterMillis/MILLIS_IN_SECOND
 152                         + "]");
 153                 // not conclusive
 154         }
 155 
 156         if (isOffLimit == Answer.NO || adjustment != -1) {
 157             System.out.println("Validating adjustment: " + adjustment);
 158             long expectedMax = distance(offset, beforeMillis/MILLIS_IN_SECOND)
 159                       * NANOS_IN_SECOND
 160                     + (beforeMillis % MILLIS_IN_SECOND) * NANOS_IN_MILLI
 161                     + (afterMillis - beforeMillis + 1) * NANOS_IN_MILLI;
 162             long absoluteAdjustment = distance(0, adjustment);
 163             if (absoluteAdjustment > expectedMax) {
 164                 long adjSec = absoluteAdjustment / NANOS_IN_SECOND;
 165                 long adjMil = (absoluteAdjustment % NANOS_IN_SECOND) / NANOS_IN_MILLI;
 166                 long adjMic = (absoluteAdjustment % NANOS_IN_MILLI) / NANOS_IN_MICRO;
 167                 long adjNan = (absoluteAdjustment % NANOS_IN_MICRO);
 168                 long expSec = expectedMax / NANOS_IN_SECOND;
 169                 long expMil = (expectedMax % NANOS_IN_SECOND) / NANOS_IN_MILLI;
 170                 long expMic = (expectedMax % NANOS_IN_MILLI) / NANOS_IN_MICRO;
 171                 long expNan = (expectedMax % NANOS_IN_MICRO);
 172                 System.err.println("Excessive adjustment: " + adjSec + "s, "
 173                         + adjMil + "ms, " + adjMic + "mics, " + adjNan + "ns");
 174                 System.err.println("Epected max: " + expSec + "s, "
 175                         + expMil + "ms, " + expMic + "mics, " + expNan + "ns");
 176 
 177                 throw new RuntimeException(name
 178                     + ": Excessive adjustment: " + adjustment
 179                     + " when time in millis is in ["
 180                     + beforeMillis + ", " + afterMillis
 181                     + "] and offset in seconds is " + offset);
 182             }
 183         }
 184 
 185     }
 186 
 187     static void regular() {
 188         System.out.println("*** Testing regular cases ***");
 189         final long start = System.currentTimeMillis();
 190         long offset = start/1000;
 191         long adjustment = VM.getNanoTimeAdjustment(offset);
 192         if (start != offset*1000) {
 193             if (adjustment == -1) {
 194                 throw new RuntimeException("VM says " + offset
 195                         + " secs is too far off, but time millis is "
 196                         + System.currentTimeMillis());
 197             }
 198         }
 199         if (adjustment == -1) {
 200             offset = System.currentTimeMillis()/1000 - 1024;
 201             adjustment = VM.getNanoTimeAdjustment(offset);
 202             if (adjustment == -1) {
 203                 throw new RuntimeException("VM says " + offset
 204                         + " secs is too far off, but time millis is "
 205                         + System.currentTimeMillis());
 206             }
 207         }
 208         if (adjustment > (start/1000 - offset + 20)*NANOS_IN_SECOND) {
 209             throw new RuntimeException("Excessive adjustment: " + adjustment);
 210         }
 211         testWithOffset("System.currentTimeMillis()/1000",
 212                 System.currentTimeMillis()/1000);
 213         testWithOffset("System.currentTimeMillis()/1000 - 1024",
 214                 System.currentTimeMillis()/1000 - 1024);
 215         testWithOffset("System.currentTimeMillis()/1000 + 1024",
 216                 System.currentTimeMillis()/1000 + 1024);
 217     }
 218 
 219     static void testLimits() {
 220         System.out.println("*** Testing limits ***");
 221         testWithOffset("System.currentTimeMillis()/1000 - MAX_OFFSET + 1",
 222                 System.currentTimeMillis()/1000 - MAX_OFFSET + 1);
 223         testWithOffset("System.currentTimeMillis()/1000 + MAX_OFFSET - 1",
 224                 System.currentTimeMillis()/1000 + MAX_OFFSET - 1);
 225         testWithOffset("System.currentTimeMillis()/1000 - MAX_OFFSET",
 226                 System.currentTimeMillis()/1000 - MAX_OFFSET);
 227         testWithOffset("System.currentTimeMillis()/1000 + MAX_OFFSET",
 228                 System.currentTimeMillis()/1000 + MAX_OFFSET);
 229         testWithOffset("System.currentTimeMillis()/1000 - MAX_OFFSET - 1024",
 230                 System.currentTimeMillis()/1000 - MAX_OFFSET - 1024);
 231         testWithOffset("System.currentTimeMillis()/1000 + MAX_OFFSET + 1024",
 232                 System.currentTimeMillis()/1000 + MAX_OFFSET + 1024);
 233         testWithOffset("0", 0);
 234         testWithOffset("-1", -1);
 235         testWithOffset("Integer.MAX_VALUE + System.currentTimeMillis()/1000",
 236                 ((long)Integer.MAX_VALUE) + System.currentTimeMillis()/1000);
 237         testWithOffset("System.currentTimeMillis()/1000 - Integer.MIN_VALUE",
 238                 System.currentTimeMillis()/1000 - Integer.MIN_VALUE);
 239         testWithOffset("Long.MAX_VALUE", Long.MAX_VALUE);
 240         testWithOffset("System.currentTimeMillis()/1000 - Long.MIN_VALUE",
 241                 (Long.MIN_VALUE + System.currentTimeMillis()/1000)*-1);
 242     }
 243 
 244     public static void main(String[] args) throws Exception {
 245         regular();
 246         testLimits();
 247     }
 248 
 249 }