waf, waflib: import unpacked waf 1.7.13
[pd-aubio.git] / waflib / Runner.py
1 #! /usr/bin/env python
2 # encoding: utf-8
3 # WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
4
5 import random,atexit
6 try:
7         from queue import Queue
8 except ImportError:
9         from Queue import Queue
10 from waflib import Utils,Task,Errors,Logs
11 GAP=10
12 class TaskConsumer(Utils.threading.Thread):
13         def __init__(self):
14                 Utils.threading.Thread.__init__(self)
15                 self.ready=Queue()
16                 self.setDaemon(1)
17                 self.start()
18         def run(self):
19                 try:
20                         self.loop()
21                 except Exception:
22                         pass
23         def loop(self):
24                 while 1:
25                         tsk=self.ready.get()
26                         if not isinstance(tsk,Task.TaskBase):
27                                 tsk(self)
28                         else:
29                                 tsk.process()
30 pool=Queue()
31 def get_pool():
32         try:
33                 return pool.get(False)
34         except Exception:
35                 return TaskConsumer()
36 def put_pool(x):
37         pool.put(x)
38 def _free_resources():
39         global pool
40         lst=[]
41         while pool.qsize():
42                 lst.append(pool.get())
43         for x in lst:
44                 x.ready.put(None)
45         for x in lst:
46                 x.join()
47         pool=None
48 atexit.register(_free_resources)
49 class Parallel(object):
50         def __init__(self,bld,j=2):
51                 self.numjobs=j
52                 self.bld=bld
53                 self.outstanding=[]
54                 self.frozen=[]
55                 self.out=Queue(0)
56                 self.count=0
57                 self.processed=1
58                 self.stop=False
59                 self.error=[]
60                 self.biter=None
61                 self.dirty=False
62         def get_next_task(self):
63                 if not self.outstanding:
64                         return None
65                 return self.outstanding.pop(0)
66         def postpone(self,tsk):
67                 if random.randint(0,1):
68                         self.frozen.insert(0,tsk)
69                 else:
70                         self.frozen.append(tsk)
71         def refill_task_list(self):
72                 while self.count>self.numjobs*GAP:
73                         self.get_out()
74                 while not self.outstanding:
75                         if self.count:
76                                 self.get_out()
77                         elif self.frozen:
78                                 try:
79                                         cond=self.deadlock==self.processed
80                                 except AttributeError:
81                                         pass
82                                 else:
83                                         if cond:
84                                                 msg='check the build order for the tasks'
85                                                 for tsk in self.frozen:
86                                                         if not tsk.run_after:
87                                                                 msg='check the methods runnable_status'
88                                                                 break
89                                                 lst=[]
90                                                 for tsk in self.frozen:
91                                                         lst.append('%s\t-> %r'%(repr(tsk),[id(x)for x in tsk.run_after]))
92                                                 raise Errors.WafError('Deadlock detected: %s%s'%(msg,''.join(lst)))
93                                 self.deadlock=self.processed
94                         if self.frozen:
95                                 self.outstanding+=self.frozen
96                                 self.frozen=[]
97                         elif not self.count:
98                                 self.outstanding.extend(self.biter.next())
99                                 self.total=self.bld.total()
100                                 break
101         def add_more_tasks(self,tsk):
102                 if getattr(tsk,'more_tasks',None):
103                         self.outstanding+=tsk.more_tasks
104                         self.total+=len(tsk.more_tasks)
105         def get_out(self):
106                 tsk=self.out.get()
107                 if not self.stop:
108                         self.add_more_tasks(tsk)
109                 self.count-=1
110                 self.dirty=True
111                 return tsk
112         def error_handler(self,tsk):
113                 if not self.bld.keep:
114                         self.stop=True
115                 self.error.append(tsk)
116         def add_task(self,tsk):
117                 try:
118                         self.pool
119                 except AttributeError:
120                         self.init_task_pool()
121                 self.ready.put(tsk)
122         def init_task_pool(self):
123                 pool=self.pool=[get_pool()for i in range(self.numjobs)]
124                 self.ready=Queue(0)
125                 def setq(consumer):
126                         consumer.ready=self.ready
127                 for x in pool:
128                         x.ready.put(setq)
129                 return pool
130         def free_task_pool(self):
131                 def setq(consumer):
132                         consumer.ready=Queue(0)
133                         self.out.put(self)
134                 try:
135                         pool=self.pool
136                 except AttributeError:
137                         pass
138                 else:
139                         for x in pool:
140                                 self.ready.put(setq)
141                         for x in pool:
142                                 self.get_out()
143                         for x in pool:
144                                 put_pool(x)
145                         self.pool=[]
146         def start(self):
147                 self.total=self.bld.total()
148                 while not self.stop:
149                         self.refill_task_list()
150                         tsk=self.get_next_task()
151                         if not tsk:
152                                 if self.count:
153                                         continue
154                                 else:
155                                         break
156                         if tsk.hasrun:
157                                 self.processed+=1
158                                 continue
159                         if self.stop:
160                                 break
161                         try:
162                                 st=tsk.runnable_status()
163                         except Exception:
164                                 self.processed+=1
165                                 tsk.err_msg=Utils.ex_stack()
166                                 if not self.stop and self.bld.keep:
167                                         tsk.hasrun=Task.SKIPPED
168                                         if self.bld.keep==1:
169                                                 if Logs.verbose>1 or not self.error:
170                                                         self.error.append(tsk)
171                                                 self.stop=True
172                                         else:
173                                                 if Logs.verbose>1:
174                                                         self.error.append(tsk)
175                                         continue
176                                 tsk.hasrun=Task.EXCEPTION
177                                 self.error_handler(tsk)
178                                 continue
179                         if st==Task.ASK_LATER:
180                                 self.postpone(tsk)
181                         elif st==Task.SKIP_ME:
182                                 self.processed+=1
183                                 tsk.hasrun=Task.SKIPPED
184                                 self.add_more_tasks(tsk)
185                         else:
186                                 tsk.position=(self.processed,self.total)
187                                 self.count+=1
188                                 tsk.master=self
189                                 self.processed+=1
190                                 if self.numjobs==1:
191                                         tsk.process()
192                                 else:
193                                         self.add_task(tsk)
194                 while self.error and self.count:
195                         self.get_out()
196                 assert(self.count==0 or self.stop)
197                 self.free_task_pool()