hotspot/test/compiler/unsafe/JdkInternalMiscUnsafeAccessTestDouble.java
changeset 45514 0fc9cc73ce45
parent 42307 cefc81dc1d52
equal deleted inserted replaced
45513:5431282d8ce1 45514:0fc9cc73ce45
     1 /*
     1 /*
     2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     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
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.
     7  * published by the Free Software Foundation.
   178 
   178 
   179         UNSAFE.putDouble(base, offset, 1.0d);
   179         UNSAFE.putDouble(base, offset, 1.0d);
   180 
   180 
   181         // Compare
   181         // Compare
   182         {
   182         {
   183             boolean r = UNSAFE.compareAndSwapDouble(base, offset, 1.0d, 2.0d);
   183             boolean r = UNSAFE.compareAndSetDouble(base, offset, 1.0d, 2.0d);
   184             assertEquals(r, true, "success compareAndSwap double");
   184             assertEquals(r, true, "success compareAndSet double");
   185             double x = UNSAFE.getDouble(base, offset);
   185             double x = UNSAFE.getDouble(base, offset);
   186             assertEquals(x, 2.0d, "success compareAndSwap double value");
   186             assertEquals(x, 2.0d, "success compareAndSet double value");
   187         }
   187         }
   188 
   188 
   189         {
   189         {
   190             boolean r = UNSAFE.compareAndSwapDouble(base, offset, 1.0d, 3.0d);
   190             boolean r = UNSAFE.compareAndSetDouble(base, offset, 1.0d, 3.0d);
   191             assertEquals(r, false, "failing compareAndSwap double");
   191             assertEquals(r, false, "failing compareAndSet double");
   192             double x = UNSAFE.getDouble(base, offset);
   192             double x = UNSAFE.getDouble(base, offset);
   193             assertEquals(x, 2.0d, "failing compareAndSwap double value");
   193             assertEquals(x, 2.0d, "failing compareAndSet double value");
   194         }
   194         }
   195 
   195 
   196         // Advanced compare
   196         // Advanced compare
   197         {
   197         {
   198             double r = UNSAFE.compareAndExchangeDoubleVolatile(base, offset, 2.0d, 1.0d);
   198             double r = UNSAFE.compareAndExchangeDouble(base, offset, 2.0d, 1.0d);
   199             assertEquals(r, 2.0d, "success compareAndExchangeVolatile double");
   199             assertEquals(r, 2.0d, "success compareAndExchange double");
   200             double x = UNSAFE.getDouble(base, offset);
   200             double x = UNSAFE.getDouble(base, offset);
   201             assertEquals(x, 1.0d, "success compareAndExchangeVolatile double value");
   201             assertEquals(x, 1.0d, "success compareAndExchange double value");
   202         }
   202         }
   203 
   203 
   204         {
   204         {
   205             double r = UNSAFE.compareAndExchangeDoubleVolatile(base, offset, 2.0d, 3.0d);
   205             double r = UNSAFE.compareAndExchangeDouble(base, offset, 2.0d, 3.0d);
   206             assertEquals(r, 1.0d, "failing compareAndExchangeVolatile double");
   206             assertEquals(r, 1.0d, "failing compareAndExchange double");
   207             double x = UNSAFE.getDouble(base, offset);
   207             double x = UNSAFE.getDouble(base, offset);
   208             assertEquals(x, 1.0d, "failing compareAndExchangeVolatile double value");
   208             assertEquals(x, 1.0d, "failing compareAndExchange double value");
   209         }
   209         }
   210 
   210 
   211         {
   211         {
   212             double r = UNSAFE.compareAndExchangeDoubleAcquire(base, offset, 1.0d, 2.0d);
   212             double r = UNSAFE.compareAndExchangeDoubleAcquire(base, offset, 1.0d, 2.0d);
   213             assertEquals(r, 1.0d, "success compareAndExchangeAcquire double");
   213             assertEquals(r, 1.0d, "success compareAndExchangeAcquire double");
   237         }
   237         }
   238 
   238 
   239         {
   239         {
   240             boolean success = false;
   240             boolean success = false;
   241             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   241             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   242                 success = UNSAFE.weakCompareAndSwapDouble(base, offset, 1.0d, 2.0d);
   242                 success = UNSAFE.weakCompareAndSetDoublePlain(base, offset, 1.0d, 2.0d);
   243             }
   243             }
   244             assertEquals(success, true, "weakCompareAndSwap double");
   244             assertEquals(success, true, "weakCompareAndSetPlain double");
   245             double x = UNSAFE.getDouble(base, offset);
   245             double x = UNSAFE.getDouble(base, offset);
   246             assertEquals(x, 2.0d, "weakCompareAndSwap double value");
   246             assertEquals(x, 2.0d, "weakCompareAndSetPlain double value");
   247         }
   247         }
   248 
   248 
   249         {
   249         {
   250             boolean success = false;
   250             boolean success = false;
   251             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   251             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   252                 success = UNSAFE.weakCompareAndSwapDoubleAcquire(base, offset, 2.0d, 1.0d);
   252                 success = UNSAFE.weakCompareAndSetDoubleAcquire(base, offset, 2.0d, 1.0d);
   253             }
   253             }
   254             assertEquals(success, true, "weakCompareAndSwapAcquire double");
   254             assertEquals(success, true, "weakCompareAndSetAcquire double");
   255             double x = UNSAFE.getDouble(base, offset);
   255             double x = UNSAFE.getDouble(base, offset);
   256             assertEquals(x, 1.0d, "weakCompareAndSwapAcquire double");
   256             assertEquals(x, 1.0d, "weakCompareAndSetAcquire double");
   257         }
   257         }
   258 
   258 
   259         {
   259         {
   260             boolean success = false;
   260             boolean success = false;
   261             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   261             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   262                 success = UNSAFE.weakCompareAndSwapDoubleRelease(base, offset, 1.0d, 2.0d);
   262                 success = UNSAFE.weakCompareAndSetDoubleRelease(base, offset, 1.0d, 2.0d);
   263             }
   263             }
   264             assertEquals(success, true, "weakCompareAndSwapRelease double");
   264             assertEquals(success, true, "weakCompareAndSetRelease double");
   265             double x = UNSAFE.getDouble(base, offset);
   265             double x = UNSAFE.getDouble(base, offset);
   266             assertEquals(x, 2.0d, "weakCompareAndSwapRelease double");
   266             assertEquals(x, 2.0d, "weakCompareAndSetRelease double");
   267         }
   267         }
   268 
   268 
   269         {
   269         {
   270             boolean success = false;
   270             boolean success = false;
   271             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   271             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
   272                 success = UNSAFE.weakCompareAndSwapDoubleVolatile(base, offset, 2.0d, 1.0d);
   272                 success = UNSAFE.weakCompareAndSetDouble(base, offset, 2.0d, 1.0d);
   273             }
   273             }
   274             assertEquals(success, true, "weakCompareAndSwapVolatile double");
   274             assertEquals(success, true, "weakCompareAndSet double");
   275             double x = UNSAFE.getDouble(base, offset);
   275             double x = UNSAFE.getDouble(base, offset);
   276             assertEquals(x, 1.0d, "weakCompareAndSwapVolatile double");
   276             assertEquals(x, 1.0d, "weakCompareAndSet double");
   277         }
   277         }
   278 
   278 
   279         UNSAFE.putDouble(base, offset, 2.0d);
   279         UNSAFE.putDouble(base, offset, 2.0d);
   280 
   280 
   281         // Compare set and get
   281         // Compare set and get
   304             double x = UNSAFE.getDouble(address);
   304             double x = UNSAFE.getDouble(address);
   305             assertEquals(x, 1.0d, "set double value");
   305             assertEquals(x, 1.0d, "set double value");
   306         }
   306         }
   307     }
   307     }
   308 }
   308 }
   309