Finalizing the beta version of the implementation for Groovy extension in JPF: JPF...
[jpf-core.git] / src / peers / gov / nasa / jpf / vm / JPF_java_lang_Thread.java
1 /*
2  * Copyright (C) 2014, United States Government, as represented by the
3  * Administrator of the National Aeronautics and Space Administration.
4  * All rights reserved.
5  *
6  * The Java Pathfinder core (jpf-core) platform is licensed under the
7  * Apache License, Version 2.0 (the "License"); you may not use this file except
8  * in compliance with the License. You may obtain a copy of the License at
9  * 
10  *        http://www.apache.org/licenses/LICENSE-2.0. 
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and 
16  * limitations under the License.
17  */
18 package gov.nasa.jpf.vm;
19
20 import gov.nasa.jpf.JPF;
21 import gov.nasa.jpf.JPFException;
22 import gov.nasa.jpf.annotation.MJI;
23 import gov.nasa.jpf.util.JPFLogger;
24
25
26 /**
27  * MJI NativePeer class for java.lang.Thread library abstraction
28  * 
29  * NOTE - this implementation depends on all live thread objects being
30  * in ThreadList
31  */
32 public class JPF_java_lang_Thread extends NativePeer {
33
34   static JPFLogger log = JPF.getLogger("gov.nasa.jpf.vm.ThreadInfo");
35   
36   
37   /**
38    * This method is the common initializer for all Thread ctors, and the only
39    * single location where we can init our ThreadInfo, but it is PRIVATE
40    */
41   @MJI
42   public void init0__Ljava_lang_ThreadGroup_2Ljava_lang_Runnable_2Ljava_lang_String_2J__V (MJIEnv env,
43                          int objRef, int groupRef, int runnableRef, int nameRef, long stackSize) {
44     VM vm = env.getVM();
45
46     // we only need to create the ThreadInfo - its initialization will take care
47     // of proper linkage to the java.lang.Thread object (objRef)
48     vm.createThreadInfo( objRef, groupRef, runnableRef, nameRef);
49   }
50
51   @MJI
52   public boolean isAlive____Z (MJIEnv env, int objref) {
53     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
54     if (ti != null){
55       return ti.isAlive();
56     } else {
57       return false; // not in ThreadList anymore
58     }
59   }
60
61   @MJI
62   public void setDaemon0__Z__V (MJIEnv env, int objref, boolean isDaemon) {
63     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
64     ti.setDaemon(isDaemon);
65   }
66
67   @MJI
68   public void dumpStack____V (MJIEnv env, int clsObjRef){
69     ThreadInfo ti = env.getThreadInfo();
70     ti.printStackTrace(); // this is not correct, we should go through VM.print
71   }
72
73   @MJI
74   public void setName0__Ljava_lang_String_2__V (MJIEnv env, int objref, int nameRef) {
75     // it bails if you try to set a null name
76     if (nameRef == MJIEnv.NULL) {
77       env.throwException("java.lang.IllegalArgumentException");
78
79       return;
80     }
81
82     // we have to intercept this to cache the name as a Java object
83     // (to be stored in ThreadData)
84     // luckily enough, it's copied into the java.lang.Thread object
85     // as a char[], i.e. does not have to preserve identity
86     // Note the nastiness in here - the java.lang.Thread object is only used
87     // to get the initial values into ThreadData, and gets inconsistent
88     // if this method is called (just works because the 'name' field is only
89     // directly accessed from within the Thread ctors)
90     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
91     ti.setName(env.getStringObject(nameRef));
92   }
93
94   @MJI
95   public void setPriority0__I__V (MJIEnv env, int objref, int prio) {
96     // again, we have to cache this in ThreadData for performance reasons
97     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
98     
99     if (prio != ti.getPriority()){
100       ti.setPriority(prio);
101     
102       // this could cause a context switch in a priority based scheduler
103       if (ti.getScheduler().setsPriorityCG(ti)){
104         env.repeatInvocation();
105         return;
106       }
107     }
108   }
109
110   @MJI
111   public int countStackFrames____I (MJIEnv env, int objref) {
112     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
113     return ti.countStackFrames();
114   }
115
116   @MJI
117   public int currentThread____Ljava_lang_Thread_2 (MJIEnv env, int clsObjRef) {
118     ThreadInfo ti = env.getThreadInfo();
119     return ti.getThreadObjectRef();
120   }
121
122   @MJI
123   public boolean holdsLock__Ljava_lang_Object_2__Z (MJIEnv env, int clsObjRef, int objref) {
124     ThreadInfo  ti = env.getThreadInfo();
125     ElementInfo ei = env.getElementInfo(objref);
126
127     return ei.isLockedBy(ti);
128   }
129
130   @MJI
131   public void interrupt____V (MJIEnv env, int objref) {
132     ThreadInfo tiCurrent = env.getThreadInfo();
133     ThreadInfo tiInterrupted = env.getThreadInfoForObjRef(objref);
134
135     if (!tiCurrent.isFirstStepInsn()) {
136       tiInterrupted.interrupt();
137     }
138     
139     if (tiCurrent.getScheduler().setsInterruptCG(tiCurrent, tiInterrupted)) {
140       env.repeatInvocation();
141       return;
142     }
143   }
144
145   // these could be in the model, but we keep it symmetric, which also saves
146   // us the effort of avoiding unwanted shared object field access CGs
147   @MJI
148   public boolean isInterrupted____Z (MJIEnv env, int objref) {
149     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
150     return ti.isInterrupted(false);
151   }
152
153   @MJI
154   public boolean interrupted____Z (MJIEnv env, int clsObjRef) {
155     ThreadInfo ti = env.getThreadInfo();
156     return ti.isInterrupted(true);
157   }
158
159   @MJI
160   public void start____V (MJIEnv env, int objref) {
161     ThreadInfo tiCurrent = env.getThreadInfo();
162     ThreadInfo tiStarted = env.getThreadInfoForObjRef(objref);
163     VM vm = tiCurrent.getVM();
164
165     //--- actions that are only performed upon first execution
166     if (!tiCurrent.isFirstStepInsn()){
167       if (tiStarted.isStopped()) {
168         // don't do anything but set it terminated - it hasn't acquired any resources yet.
169         // note that apparently host VMs don't schedule this thread, so there is no handler invocation
170         tiStarted.setTerminated();
171         return;
172       }
173
174       if (!tiStarted.isNew()) {
175         // alredy running, throw a IllegalThreadStateException. If it already terminated, it just gets
176         // silently ignored in Java 1.4, but the 1.5 spec explicitly marks this
177         // as illegal, so we adopt this by throwing an IllegalThreadState, too
178         env.throwException("java.lang.IllegalThreadStateException");
179         return;
180       }
181
182       int runnableRef = tiStarted.getRunnableRef();
183       if (runnableRef == MJIEnv.NULL) {
184         // note that we don't set the 'tiSuspended' field, since java.lang.Thread doesn't
185         runnableRef = objref;
186       }
187
188       ElementInfo eiTarget = env.getElementInfo(runnableRef);
189       ClassInfo   ci = eiTarget.getClassInfo();
190       MethodInfo  miRun = ci.getMethod("run()V", true);
191
192       // we do direct call run() invocation so that we have a well defined
193       // exit point (DIRECTCALLRETURN) in case the thread is stopped or there is
194       // a fail-safe UncaughtExceptionHandler set
195       DirectCallStackFrame runFrame = miRun.createRunStartStackFrame(tiStarted);
196       runFrame.setReferenceArgument(0, runnableRef, null);
197             
198       tiStarted.pushFrame(runFrame);
199       tiStarted.setState(ThreadInfo.State.RUNNING);
200       
201       vm.notifyThreadStarted(tiStarted);
202     }
203     
204     //--- scheduling point
205     if (tiCurrent.getScheduler().setsStartCG(tiCurrent, tiStarted)){
206       env.repeatInvocation();
207     }
208     // everything that would follow would be re-executed
209   }
210
211   @MJI
212   public void yield____V (MJIEnv env, int clsObjRef) {
213     ThreadInfo ti = env.getThreadInfo();
214     if (ti.getScheduler().setsYieldCG(ti)){
215       env.repeatInvocation();
216     }
217   }
218
219   @MJI
220   public void sleep__JI__V (MJIEnv env, int clsObjRef, long millis, int nanos) {
221     ThreadInfo ti = env.getThreadInfo();
222
223     // check scheduling point
224     if (ti.getScheduler().setsSleepCG(ti, millis, nanos)){
225       ti.setSleeping();
226       env.repeatInvocation();
227       return;
228     }
229     
230     if (ti.isSleeping()){
231       ti.setRunning();
232     }
233   }
234
235   @MJI
236   public void suspend____V (MJIEnv env, int threadObjRef) {
237     ThreadInfo tiCurrent = env.getThreadInfo();
238     ThreadInfo tiSuspended = env.getThreadInfoForObjRef(threadObjRef);
239
240     if (tiSuspended.isTerminated()) {
241       return;  // nothing to do, it's already gone
242     }
243     
244     if (!tiCurrent.isFirstStepInsn()){ // do this just once
245       tiSuspended.suspend();
246     }
247     
248     // scheduling point
249     if (tiCurrent.getScheduler().setsSuspendCG(tiCurrent, tiSuspended)){
250       env.repeatInvocation();      
251     }
252   }
253
254   @MJI
255   public void resume____V (MJIEnv env, int threadObjRef) {
256     ThreadInfo tiCurrent = env.getThreadInfo();
257     ThreadInfo tiResumed = env.getThreadInfoForObjRef(threadObjRef);
258
259     if (tiCurrent == tiResumed){
260       return;  // no self resume prior to suspension
261     }
262
263     if (tiResumed.isTerminated()) {
264       return;  // nothing to resume
265     }
266
267     if (!tiCurrent.isFirstStepInsn()) { // do this just once
268       tiResumed.resume();
269     }
270     
271     // check scheduling point
272     if (tiCurrent.getScheduler().setsResumeCG(tiCurrent, tiResumed)){
273       env.repeatInvocation();
274       return;
275     }
276   }
277
278   /*
279    * the join() workhorse. We use lockfree waits instead of a simple wait from a synchronized block
280    * to save states
281    */
282   protected void join0 (MJIEnv env, int joineeRef, long timeout){
283     ThreadInfo tiCurrent = env.getThreadInfo();
284     ThreadInfo tiJoinee = env.getThreadInfoForObjRef(joineeRef);
285     ElementInfo eiJoinee = env.getModifiableElementInfo(joineeRef); // the thread object to wait on
286
287     if (timeout < 0) {
288       env.throwException("java.lang.IllegalArgumentException", "timeout value is negative");
289       return;
290     }
291       
292     if (tiCurrent.isInterrupted(true)){ // interrupt status is set, throw and bail      
293       // since we use lock-free waits, we need to remove ourselves from the lock contender list
294       eiJoinee.setMonitorWithoutLocked(tiCurrent);
295       
296       // note that we have to throw even if the thread to join to is not alive anymore
297       env.throwInterrupt();
298       return;
299     }
300   
301     if (!tiCurrent.isFirstStepInsn()){ // to be executed only once    
302       if (tiJoinee.isAlive()) {
303         // block in first top half so that following transitions see this thread as not runnable
304         eiJoinee.wait( tiCurrent, timeout, false);
305       } else {
306         return; // nothing to do
307       }
308     }    
309
310     if (tiCurrent.getScheduler().setsJoinCG(tiCurrent, tiJoinee, timeout)) {
311       env.repeatInvocation();
312       return;
313     }
314     
315     // unblock in bottom half
316     switch (tiCurrent.getState()) {
317       case WAITING:
318       case TIMEOUT_WAITING:
319         throw new JPFException("blocking join without transition break");        
320       
321       case UNBLOCKED:
322         // Thread was owning the lock when it joined - we have to wait until
323         // we can reacquire it
324         eiJoinee.lockNotified(tiCurrent);
325         break;
326
327       case TIMEDOUT:
328         eiJoinee.resumeNonlockedWaiter(tiCurrent);
329         break;
330
331       case RUNNING:
332         if (tiJoinee.isAlive()) { // we still need to wait
333           eiJoinee.wait(tiCurrent, timeout, false); // no need for a new CG
334           env.repeatInvocation();
335         }
336         break;
337     }
338   }
339
340   @MJI
341   public void join____V (MJIEnv env, int objref){
342     join0(env,objref,0);
343   }
344
345   @MJI
346   public void join__J__V (MJIEnv env, int objref, long millis) {
347     join0(env,objref,millis);
348
349   }
350
351   @MJI
352   public void join__JI__V (MJIEnv env, int objref, long millis, int nanos) {
353     join0(env,objref,millis); // <2do> we ignore nanos for now
354   }
355
356   @MJI
357   public int getState0____I (MJIEnv env, int objref) {
358     // return the state index with respect to one of the public Thread.States
359     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
360
361     switch (ti.getState()) {
362       case NEW:
363         return 1;
364       case RUNNING:
365         return 2;
366       case BLOCKED:
367         return 0;
368       case UNBLOCKED:
369         return 2;
370       case WAITING:
371         return 5;
372       case TIMEOUT_WAITING:
373         return 4;
374       case SLEEPING:
375         return 4;
376       case NOTIFIED:
377         return 0;
378       case INTERRUPTED:
379         return 0;
380       case TIMEDOUT:
381         return 2;
382       case TERMINATED:
383         return 3;
384       default:
385         throw new JPFException("illegal thread state: " + ti.getState());
386     }
387   }
388
389   @MJI
390   public long getId____J (MJIEnv env, int objref) {
391     ThreadInfo ti = env.getThreadInfoForObjRef(objref);
392     return ti.getId();
393   }
394   
395   @MJI
396   public void stop____V (MJIEnv env, int threadRef) {
397     stop__Ljava_lang_Throwable_2__V(env, threadRef, MJIEnv.NULL);
398   }
399
400   @MJI
401   public void stop__Ljava_lang_Throwable_2__V (MJIEnv env, int threadRef, int throwableRef) {
402     ThreadInfo tiCurrent = env.getThreadInfo();
403     ThreadInfo tiStopped = env.getThreadInfoForObjRef(threadRef);
404
405     if (tiStopped.isTerminated() || tiStopped.isStopped()) {
406       return; // silently ignored
407     }
408
409     if (tiCurrent.getScheduler().setsStopCG(tiCurrent, tiStopped)){
410       env.repeatInvocation();
411       return;
412     }
413
414     // stop thread in bottom half
415     tiStopped.setStopped(throwableRef);
416   }
417 }