chen3feng / blade-build / 568

pending completion

Build # 568

Build Type

Pull #616

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/chen3feng/blade-build/commit/<a class=hub.com/chen3feng/blade-build/commit/<a class="double-link" href="https://git"><a class=hub.com/chen3feng/blade-build/commit/<a class="double-link" href="https://git"><a class=hub.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024a106d5d8">160bdfbe9<a href="https://github.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024a106d5d8">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/chen3feng/blade-build/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024a106d5d8&quot;&gt;160bdfbe9&lt;/a&gt;&lt;a href=&quot;https://github.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024a106d5d8&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024&lt;/a&gt;a106d5d8&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/<a class="double-link" href="https://github.com/chen3feng/blade-build/commit/68badf49ca76f24279dafbd0016908cb9a0a804e">68badf49c</a><a href="https://github.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024a106d5d8">&amp;quot;&amp;gt;68badf49c&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;68badf49c&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/chen3feng/blade-build/commit/160bdfbe94375d12bae5b26387eae024a106d&lt;/a&gt;5d8&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/chen3feng/blade-build/commit/<a class="double-link" href="https://github.com/chen3feng/blade-build/commit/217c2ab81">217c2ab81">217c2ab81</a>

Pull Request Pull Request #616: Remove scons related code

Run Details

47 of 47 new or added lines in 13 files covered. (100.0%)

2616 of 6789 relevant lines covered (38.53%)

0.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

42.37

/src/blade/cu_targets.py

# Copyright (c) 2013 Tencent Inc.
# All rights reserved.
#
# Author: LI Yi <sincereli@tencent.com>
# Created:   September 27, 2013


"""
This module defines cu_library, cu_binary and cu_test rules
for cuda development.

"""

from __future__ import absolute_import

import os

from blade import build_manager
from blade import build_rules
from blade import config
from blade.blade_util import var_to_list
from blade.cc_targets import CcTarget


class CuTarget(CcTarget):
    """This class is derived from CcTarget and is the base class
    of cu_library, cu_binary etc.

    """

    def __init__(self,
                 name,
                 target_type,
                 srcs,
                 deps,
                 warning,
                 defs,
                 incs,
                 extra_cppflags,
                 extra_linkflags,
                 blade,
                 kwargs):
        srcs = var_to_list(srcs)
        deps = var_to_list(deps)
        extra_cppflags = var_to_list(extra_cppflags)
        extra_linkflags = var_to_list(extra_linkflags)

        CcTarget.__init__(self,
                          name,
                          target_type,
                          srcs,
                          deps,
                          None,
                          warning,
                          defs,
                          incs,
                          [], [],
                          extra_cppflags,
                          extra_linkflags,
                          blade,
                          kwargs)

    def _get_cu_flags(self):
        """Return the nvcc flags according to the BUILD file and other configs. """
        nvcc_flags = []

        # Warnings
        if self.data.get('warning', '') == 'no':
            nvcc_flags.append('-w')

        # Defs
        defs = self.data.get('defs', [])
        nvcc_flags += [('-D' + macro) for macro in defs]

        # Optimize flags
        if (self.blade.get_options().profile == 'release' or
                self.data.get('always_optimize')):
            nvcc_flags += self._get_optimize_flags()

        # Incs
        incs = self._get_incs_list()

        return nvcc_flags, incs


class CuLibrary(CuTarget):
    """This class is derived from CuTarget and generates the cu_library
    rules according to user options.

    """

    def __init__(self,
                 name,
                 srcs,
                 deps,
                 warning,
                 defs,
                 incs,
                 extra_cppflags,
                 extra_linkflags,
                 blade,
                 kwargs):
        CuTarget.__init__(self,
                          name,
                          'cu_library',
                          srcs,
                          deps,
                          warning,
                          defs,
                          incs,
                          extra_cppflags,
                          extra_linkflags,
                          blade,
                          kwargs)

    def ninja_rule(self):
        self.error('to be implemented')


def cu_library(name,
               srcs=[],
               deps=[],
               warning='yes',
               defs=[],
               incs=[],
               extra_cppflags=[],
               extra_linkflags=[],
               **kwargs):
    target = CuLibrary(name,
                       srcs,
                       deps,
                       warning,
                       defs,
                       incs,
                       extra_cppflags,
                       extra_linkflags,
                       build_manager.instance,
                       kwargs)
    build_manager.instance.register_target(target)


build_rules.register_function(cu_library)


class CuBinary(CuTarget):
    """This class is derived from CuTarget and generates the cu_binary
    rules according to user options.

    """

    def __init__(self,
                 name,
                 srcs,
                 deps,
                 warning,
                 defs,
                 incs,
                 extra_cppflags,
                 extra_linkflags,
                 blade,
                 kwargs):
        CuTarget.__init__(self,
                          name,
                          'cu_binary',
                          srcs,
                          deps,
                          warning,
                          defs,
                          incs,
                          extra_cppflags,
                          extra_linkflags,
                          blade,
                          kwargs)

    def ninja_rule(self):
        self.error('to be implemented')


def cu_binary(name,
              srcs=[],
              deps=[],
              warning='yes',
              defs=[],
              incs=[],
              extra_cppflags=[],
              extra_linkflags=[],
              **kwargs):
    target = CuBinary(name,
                      srcs,
                      deps,
                      warning,
                      defs,
                      incs,
                      extra_cppflags,
                      extra_linkflags,
                      build_manager.instance,
                      kwargs)
    build_manager.instance.register_target(target)


build_rules.register_function(cu_binary)


class CuTest(CuBinary):
    """This class is derived from CuBinary and generates the cu_test
    rules according to user options.

    """

    def __init__(self,
                 name,
                 srcs,
                 deps,
                 warning,
                 defs,
                 incs,
                 extra_cppflags,
                 extra_linkflags,
                 testdata,
                 always_run,
                 exclusive,
                 blade,
                 kwargs):
        # pylint: disable=too-many-locals
        CuBinary.__init__(self,
                          name,
                          srcs,
                          deps,
                          warning,
                          defs,
                          incs,
                          extra_cppflags,
                          extra_linkflags,
                          blade,
                          kwargs)
        self.type = 'cu_test'
        self.data['testdata'] = var_to_list(testdata)
        self.data['always_run'] = always_run
        self.data['exclusive'] = exclusive

        cc_test_config = config.get_section('cc_test_config')
        gtest_lib = var_to_list(cc_test_config['gtest_libs'])
        gtest_main_lib = var_to_list(cc_test_config['gtest_main_libs'])

        # Hardcode deps rule to thirdparty gtest main lib.
        self._add_hardcode_library(gtest_lib)
        self._add_hardcode_library(gtest_main_lib)


def cu_test(name,
            srcs=[],
            deps=[],
            warning='yes',
            defs=[],
            incs=[],
            extra_cppflags=[],
            extra_linkflags=[],
            testdata=[],
            always_run=False,
            exclusive=False,
            **kwargs):
    target = CuTest(name,
                    srcs,
                    deps,
                    warning,
                    defs,
                    incs,
                    extra_cppflags,
                    extra_linkflags,
                    testdata,
                    always_run,
                    exclusive,
                    build_manager.instance,
                    kwargs)
    build_manager.instance.register_target(target)


build_rules.register_function(cu_test)

1	# Copyright (c) 2013 Tencent Inc.
2	# All rights reserved.
3	#
4	# Author: LI Yi <sincereli@tencent.com>
5	# Created: September 27, 2013
6
7
8	"""	1✔
9	This module defines cu_library, cu_binary and cu_test rules
10	for cuda development.
11
12	"""
13
14	from __future__ import absolute_import	1✔
15
16	import os	1✔
17
18	from blade import build_manager	1✔
19	from blade import build_rules	1✔
20	from blade import config	1✔
21	from blade.blade_util import var_to_list	1✔
22	from blade.cc_targets import CcTarget	1✔
23
24
25	class CuTarget(CcTarget):	1✔
26	"""This class is derived from CcTarget and is the base class
27	of cu_library, cu_binary etc.
28
29	"""
30
31	def __init__(self,	1✔
32	name,
33	target_type,
34	srcs,
35	deps,
36	warning,
37	defs,
38	incs,
39	extra_cppflags,
40	extra_linkflags,
41	blade,
42	kwargs):
43	srcs = var_to_list(srcs)	×
44	deps = var_to_list(deps)	×
45	extra_cppflags = var_to_list(extra_cppflags)	×
46	extra_linkflags = var_to_list(extra_linkflags)	×
47
48	CcTarget.__init__(self,	×
49	name,
50	target_type,
51	srcs,
52	deps,
53	None,
54	warning,
55	defs,
56	incs,
57	[], [],
58	extra_cppflags,
59	extra_linkflags,
60	blade,
61	kwargs)
62
63	def _get_cu_flags(self):	1✔
64	"""Return the nvcc flags according to the BUILD file and other configs. """
65	nvcc_flags = []	×
66
67	# Warnings
68	if self.data.get('warning', '') == 'no':	×
69	nvcc_flags.append('-w')	×
70
71	# Defs
72	defs = self.data.get('defs', [])	×
73	nvcc_flags += [('-D' + macro) for macro in defs]	×
74
75	# Optimize flags
76	if (self.blade.get_options().profile == 'release' or	×
77	self.data.get('always_optimize')):
78	nvcc_flags += self._get_optimize_flags()	×
79
80	# Incs
81	incs = self._get_incs_list()	×
82
83	return nvcc_flags, incs	×
84
85
86	class CuLibrary(CuTarget):	1✔
87	"""This class is derived from CuTarget and generates the cu_library
88	rules according to user options.
89
90	"""
91
92	def __init__(self,	1✔
93	name,
94	srcs,
95	deps,
96	warning,
97	defs,
98	incs,
99	extra_cppflags,
100	extra_linkflags,
101	blade,
102	kwargs):
103	CuTarget.__init__(self,	×
104	name,
105	'cu_library',
106	srcs,
107	deps,
108	warning,
109	defs,
110	incs,
111	extra_cppflags,
112	extra_linkflags,
113	blade,
114	kwargs)
115
116	def ninja_rule(self):	1✔
117	self.error('to be implemented')	×
118
119
120	def cu_library(name,	1✔
121	srcs=[],
122	deps=[],
123	warning='yes',
124	defs=[],
125	incs=[],
126	extra_cppflags=[],
127	extra_linkflags=[],
128	**kwargs):
129	target = CuLibrary(name,	×
130	srcs,
131	deps,
132	warning,
133	defs,
134	incs,
135	extra_cppflags,
136	extra_linkflags,
137	build_manager.instance,
138	kwargs)
139	build_manager.instance.register_target(target)	×
140
141
142	build_rules.register_function(cu_library)	1✔
143
144
145	class CuBinary(CuTarget):	1✔
146	"""This class is derived from CuTarget and generates the cu_binary
147	rules according to user options.
148
149	"""
150
151	def __init__(self,	1✔
152	name,
153	srcs,
154	deps,
155	warning,
156	defs,
157	incs,
158	extra_cppflags,
159	extra_linkflags,
160	blade,
161	kwargs):
162	CuTarget.__init__(self,	×
163	name,
164	'cu_binary',
165	srcs,
166	deps,
167	warning,
168	defs,
169	incs,
170	extra_cppflags,
171	extra_linkflags,
172	blade,
173	kwargs)
174
175	def ninja_rule(self):	1✔
176	self.error('to be implemented')	×
177
178
179	def cu_binary(name,	1✔
180	srcs=[],
181	deps=[],
182	warning='yes',
183	defs=[],
184	incs=[],
185	extra_cppflags=[],
186	extra_linkflags=[],
187	**kwargs):
188	target = CuBinary(name,	×
189	srcs,
190	deps,
191	warning,
192	defs,
193	incs,
194	extra_cppflags,
195	extra_linkflags,
196	build_manager.instance,
197	kwargs)
198	build_manager.instance.register_target(target)	×
199
200
201	build_rules.register_function(cu_binary)	1✔
202
203
204	class CuTest(CuBinary):	1✔
205	"""This class is derived from CuBinary and generates the cu_test
206	rules according to user options.
207
208	"""
209
210	def __init__(self,	1✔
211	name,
212	srcs,
213	deps,
214	warning,
215	defs,
216	incs,
217	extra_cppflags,
218	extra_linkflags,
219	testdata,
220	always_run,
221	exclusive,
222	blade,
223	kwargs):
224	# pylint: disable=too-many-locals
225	CuBinary.__init__(self,	×
226	name,
227	srcs,
228	deps,
229	warning,
230	defs,
231	incs,
232	extra_cppflags,
233	extra_linkflags,
234	blade,
235	kwargs)
236	self.type = 'cu_test'	×
237	self.data['testdata'] = var_to_list(testdata)	×
238	self.data['always_run'] = always_run	×
239	self.data['exclusive'] = exclusive	×
240
241	cc_test_config = config.get_section('cc_test_config')	×
242	gtest_lib = var_to_list(cc_test_config['gtest_libs'])	×
243	gtest_main_lib = var_to_list(cc_test_config['gtest_main_libs'])	×
244
245	# Hardcode deps rule to thirdparty gtest main lib.
246	self._add_hardcode_library(gtest_lib)	×
247	self._add_hardcode_library(gtest_main_lib)	×
248
249
250	def cu_test(name,	1✔
251	srcs=[],
252	deps=[],
253	warning='yes',
254	defs=[],
255	incs=[],
256	extra_cppflags=[],
257	extra_linkflags=[],
258	testdata=[],
259	always_run=False,
260	exclusive=False,
261	**kwargs):
262	target = CuTest(name,	×
263	srcs,
264	deps,
265	warning,
266	defs,
267	incs,
268	extra_cppflags,
269	extra_linkflags,
270	testdata,
271	always_run,
272	exclusive,
273	build_manager.instance,
274	kwargs)
275	build_manager.instance.register_target(target)	×
276
277
278	build_rules.register_function(cu_test)	1✔

chen3feng / blade-build / 568

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous