hotspot/test/compiler/unsafe/X-UnsafeAccessTest.java.template
changeset 36316 7a83de7aabca
parent 35103 d19354bcbfa6
child 36827 53d2d43551d2
equal deleted inserted replaced
36315:150a415079ae 36316:7a83de7aabca
   168             assertEquals(x, $value1$, "putRelease $type$ value");
   168             assertEquals(x, $value1$, "putRelease $type$ value");
   169         }
   169         }
   170 #end[Ordered]
   170 #end[Ordered]
   171 
   171 
   172 #if[JdkInternalMisc]
   172 #if[JdkInternalMisc]
       
   173         // Lazy
       
   174         {
       
   175             UNSAFE.put$Type$Release(base, offset, $value1$);
       
   176             $type$ x = UNSAFE.get$Type$Acquire(base, offset);
       
   177             assertEquals(x, $value1$, "putRelease $type$ value");
       
   178         }
       
   179 
       
   180         // Opaque
       
   181         {
       
   182             UNSAFE.put$Type$Opaque(base, offset, $value2$);
       
   183             $type$ x = UNSAFE.get$Type$Opaque(base, offset);
       
   184             assertEquals(x, $value2$, "putOpaque $type$ value");
       
   185         }
       
   186 #end[JdkInternalMisc]
       
   187 
       
   188 #if[JdkInternalMisc]
   173 #if[Unaligned]
   189 #if[Unaligned]
   174         // Unaligned
   190         // Unaligned
   175         {
   191         {
   176             UNSAFE.put$Type$Unaligned(base, offset, $value2$);
   192             UNSAFE.put$Type$Unaligned(base, offset, $value2$);
   177             $type$ x = UNSAFE.get$Type$Unaligned(base, offset);
   193             $type$ x = UNSAFE.get$Type$Unaligned(base, offset);
   207             boolean r = UNSAFE.compareAndSwap$Type$(base, offset, $value1$, $value3$);
   223             boolean r = UNSAFE.compareAndSwap$Type$(base, offset, $value1$, $value3$);
   208             assertEquals(r, false, "failing compareAndSwap $type$");
   224             assertEquals(r, false, "failing compareAndSwap $type$");
   209             $type$ x = UNSAFE.get$Type$(base, offset);
   225             $type$ x = UNSAFE.get$Type$(base, offset);
   210             assertEquals(x, $value2$, "failing compareAndSwap $type$ value");
   226             assertEquals(x, $value2$, "failing compareAndSwap $type$ value");
   211         }
   227         }
       
   228 
       
   229 #if[JdkInternalMisc]
       
   230         // Advanced compare
       
   231         {
       
   232             $type$ r = UNSAFE.compareAndExchange$Type$Volatile(base, offset, $value2$, $value1$);
       
   233             assertEquals(r, $value2$, "success compareAndExchangeVolatile $type$");
       
   234             $type$ x = UNSAFE.get$Type$(base, offset);
       
   235             assertEquals(x, $value1$, "success compareAndExchangeVolatile $type$ value");
       
   236         }
       
   237 
       
   238         {
       
   239             $type$ r = UNSAFE.compareAndExchange$Type$Volatile(base, offset, $value2$, $value3$);
       
   240             assertEquals(r, $value1$, "failing compareAndExchangeVolatile $type$");
       
   241             $type$ x = UNSAFE.get$Type$(base, offset);
       
   242             assertEquals(x, $value1$, "failing compareAndExchangeVolatile $type$ value");
       
   243         }
       
   244 
       
   245         {
       
   246             $type$ r = UNSAFE.compareAndExchange$Type$Acquire(base, offset, $value1$, $value2$);
       
   247             assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
       
   248             $type$ x = UNSAFE.get$Type$(base, offset);
       
   249             assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value");
       
   250         }
       
   251 
       
   252         {
       
   253             $type$ r = UNSAFE.compareAndExchange$Type$Acquire(base, offset, $value1$, $value3$);
       
   254             assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
       
   255             $type$ x = UNSAFE.get$Type$(base, offset);
       
   256             assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value");
       
   257         }
       
   258 
       
   259         {
       
   260             $type$ r = UNSAFE.compareAndExchange$Type$Release(base, offset, $value2$, $value1$);
       
   261             assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
       
   262             $type$ x = UNSAFE.get$Type$(base, offset);
       
   263             assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value");
       
   264         }
       
   265 
       
   266         {
       
   267             $type$ r = UNSAFE.compareAndExchange$Type$Release(base, offset, $value2$, $value3$);
       
   268             assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
       
   269             $type$ x = UNSAFE.get$Type$(base, offset);
       
   270             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
       
   271         }
       
   272 
       
   273         {
       
   274             boolean r = UNSAFE.weakCompareAndSwap$Type$(base, offset, $value1$, $value2$);
       
   275             assertEquals(r, true, "weakCompareAndSwap $type$");
       
   276             $type$ x = UNSAFE.get$Type$(base, offset);
       
   277             assertEquals(x, $value2$, "weakCompareAndSwap $type$ value");
       
   278         }
       
   279 
       
   280         {
       
   281             boolean r = UNSAFE.weakCompareAndSwap$Type$Acquire(base, offset, $value2$, $value1$);
       
   282             assertEquals(r, true, "weakCompareAndSwapAcquire $type$");
       
   283             $type$ x = UNSAFE.get$Type$(base, offset);
       
   284             assertEquals(x, $value1$, "weakCompareAndSwapAcquire $type$");
       
   285         }
       
   286 
       
   287         {
       
   288             boolean r = UNSAFE.weakCompareAndSwap$Type$Release(base, offset, $value1$, $value2$);
       
   289             assertEquals(r, true, "weakCompareAndSwapRelease $type$");
       
   290             $type$ x = UNSAFE.get$Type$(base, offset);
       
   291             assertEquals(x, $value2$, "weakCompareAndSwapRelease $type$");
       
   292         }
       
   293 #end[JdkInternalMisc]
   212 
   294 
   213         // Compare set and get
   295         // Compare set and get
   214         {
   296         {
   215             $type$ o = UNSAFE.getAndSet$Type$(base, offset, $value1$);
   297             $type$ o = UNSAFE.getAndSet$Type$(base, offset, $value1$);
   216             assertEquals(o, $value2$, "getAndSet $type$");
   298             assertEquals(o, $value2$, "getAndSet $type$");
   243         }
   325         }
   244     }
   326     }
   245 #end[!boolean]
   327 #end[!boolean]
   246 #end[!Object]
   328 #end[!Object]
   247 }
   329 }
       
   330