Code coverage tests
This page documents the degree to which the PARI/GP source code is tested by
our public test suite, distributed with the source distribution in directory
src/test/. This is measured by the gcov utility; we then
process gcov output using the lcov frond-end.
We test a few variants depending on Configure flags
on the pari.math.u-bordeaux.fr machine (x86_64
architecture), and agregate them in the final report:
- with GMP kernel
- with GMP kernel using --mt=pthread
- with native kernel, including micro-assembler code
- with native kernel, without micro-assembler
- with native kernel, without micro-assembler, disabling GCC extensions
(DISABLE_INLINE)
- with GMP kernel, emulating an
x86_32 architecture at
Configure time via setarch
The target is to exceed 90% coverage for all mathematical modules
(given that branches depending on DEBUGLEVEL
or DEBUGMEM are not covered). This script is
run to produce the results below.
| LCOV - code coverage report |
 |
|
|
|
|
Line data Source code
1 : /* $Id$
2 :
3 : Copyright (C) 2013 The PARI group.
4 :
5 : This file is part of the PARI/GP package.
6 :
7 : PARI/GP is free software; you can redistribute it and/or modify it under the
8 : terms of the GNU General Public License as published by the Free Software
9 : Foundation; either version 2 of the License, or (at your option) any later
10 : version. It is distributed in the hope that it will be useful, but WITHOUT
11 : ANY WARRANTY WHATSOEVER.
12 :
13 : Check the License for details. You should have received a copy of it, along
14 : with the package; see the file 'COPYING'. If not, write to the Free Software
15 : Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
16 : #include "pari.h"
17 : #include "paripriv.h"
18 : #include "mt.h"
19 :
20 : static GEN
21 3832743 : mtsingle_queue_get(struct mt_state *mt, long *workid, long *pending)
22 : {
23 3832743 : GEN done = mt->pending;
24 3832743 : if (workid) *workid = mt->workid;
25 3832743 : mt->pending = NULL; *pending = 0;
26 3832743 : return done;
27 : }
28 :
29 : static int single_is_thread = 0;
30 : static long single_trace_level = 0;
31 :
32 : static void
33 3832769 : mtsingle_queue_submit(struct mt_state *mt, long workid, GEN work)
34 : {
35 3832769 : int is_thread = single_is_thread;
36 3832769 : single_is_thread = 1;
37 3832769 : mt->pending = work? closure_callgenvec(mt->worker, work): NULL;
38 3832743 : single_is_thread = is_thread;
39 3832743 : mt->workid = workid;
40 3832743 : }
41 :
42 : static void
43 910949 : mtsingle_queue_end(void) { }
44 :
45 : static GEN
46 214826 : mtsequential_queue_get(struct mt_state *mt, long *workid, long *pending)
47 : {
48 214826 : GEN done = mt->pending;
49 214826 : if (workid) *workid = mt->workid;
50 214826 : mt->pending = NULL; *pending = 0;
51 214826 : return done;
52 : }
53 :
54 : static void
55 214894 : mtsequential_queue_submit(struct mt_state *mt, long workid, GEN work)
56 : {
57 214894 : mt->pending = work? closure_callgenvec(mt->worker, work): NULL;
58 214824 : mt->workid = workid;
59 214824 : }
60 :
61 : static void
62 42377 : mtsequential_queue_end(void) { }
63 :
64 : int
65 216322321 : mtsingle_is_thread(void) { return single_is_thread; }
66 :
67 : void
68 12755 : mtsingle_err_recover(long er)
69 : {
70 : (void) er;
71 12755 : if (single_is_thread)
72 : {
73 18 : evalstate_set_trace(single_trace_level);
74 18 : single_is_thread = 0;
75 : }
76 12755 : }
77 :
78 : void
79 910975 : mtsingle_queue_start(struct pari_mt *pt, GEN worker)
80 : {
81 910975 : pt->get = mtsingle_queue_get;
82 910975 : pt->submit = mtsingle_queue_submit;
83 910975 : pt->end = mtsingle_queue_end;
84 910975 : pt->mt.worker = worker;
85 910975 : pt->mt.pending = NULL;
86 910975 : single_trace_level = evalstate_get_trace();
87 910975 : }
88 :
89 : void
90 42380 : mtsequential_queue_start(struct pari_mt *pt, GEN worker)
91 : {
92 42380 : pt->get = mtsequential_queue_get;
93 42380 : pt->submit = mtsequential_queue_submit;
94 42380 : pt->end = mtsequential_queue_end;
95 42380 : pt->mt.worker = worker;
96 42380 : pt->mt.pending = NULL;
97 42380 : }
98 :
99 : void
100 1012133 : mt_queue_end(struct pari_mt *pt) { pt->end(); }
101 :
102 : void
103 4747981 : mt_queue_submit(struct pari_mt *pt, long workid, GEN work)
104 4747981 : { pt->submit(&pt->mt, workid, work); }
105 :
106 : GEN
107 4747889 : mt_queue_get(struct pari_mt *pt, long *workid, long *pending)
108 4747889 : { return pt->get(&pt->mt, workid, pending); }
109 :
110 : void
111 87 : mt_queue_start(struct pari_mt *pt, GEN worker)
112 87 : { return mt_queue_start_lim(pt, worker, 0); }
113 :
114 : void
115 1419269 : mtstate_save(struct pari_mtstate *mt)
116 : {
117 1419269 : if (mt_is_parallel())
118 : {
119 176 : mt->is_thread = 0;
120 176 : mt->trace_level = 0;
121 176 : mt->pending_threads = 1;
122 : } else
123 : {
124 1419093 : mt->is_thread = single_is_thread;
125 1419093 : mt->trace_level = single_trace_level;
126 1419093 : mt->pending_threads = 0;
127 : }
128 1419269 : }
129 :
130 : void
131 49052 : mtstate_restore(struct pari_mtstate *mt)
132 : {
133 49052 : if (!mt_is_parallel())
134 : {
135 49043 : single_is_thread = mt->is_thread;
136 49043 : single_trace_level = mt->trace_level;
137 : }
138 49052 : if (!mt->pending_threads && mt_is_parallel())
139 7 : mt_queue_reset();
140 49052 : }
141 :
142 : void
143 438 : mtstate_reset(void)
144 : {
145 438 : single_is_thread = 0;
146 438 : single_trace_level = 0;
147 438 : if (mt_is_parallel())
148 0 : mt_queue_reset();
149 438 : }
|