zgetrf_incpiv.c 9.68 KB
Newer Older
1
2
/**
 *
3
4
 * @copyright (c) 2009-2014 The University of Tennessee and The University
 *                          of Tennessee Research Foundation.
5
6
 *                          All rights reserved.
 * @copyright (c) 2012-2014 Inria. All rights reserved.
7
 * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 *
 **/

/**
 *
 * @file zgetrf_incpiv.c
 *
 *  MORSE computational routines
 *  MORSE is a software package provided by Univ. of Tennessee,
 *  Univ. of California Berkeley and Univ. of Colorado Denver
 *
 * @version 2.5.0
 * @comment This file has been automatically generated
 *          from Plasma 2.5.0 for MORSE 1.0.0
 * @author Jakub Kurzak
 * @author Mathieu Faverge
 * @author Emmanuel Agullo
 * @author Cedric Castagnede
 * @date 2010-11-15
 * @precisions normal z -> s d c
 *
 **/
30
#include "control/common.h"
31

32
33
/**
 ********************************************************************************
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 *
 * @ingroup MORSE_Complex64_t
 *
 *  MORSE_zgetrf_incpiv - Computes an LU factorization of a general M-by-N matrix A
 *  using the tile LU algorithm with partial tile pivoting with row interchanges.
 *
 *******************************************************************************
 *
 * @param[in] M
 *          The number of rows of the matrix A. M >= 0.
 *
 * @param[in] N
 *          The number of columns of the matrix A. N >= 0.
 *
 * @param[in,out] A
 *          On entry, the M-by-N matrix to be factored.
 *          On exit, the tile factors L and U from the factorization.
 *
 * @param[in] LDA
 *          The leading dimension of the array A. LDA >= max(1,M).
 *
 * @param[out] descL
 *          On exit, auxiliary factorization data, related to the tile L factor,
 *          required by MORSE_zgetrs_incpiv to solve the system of equations.
 *
 * @param[out] IPIV
 *          The pivot indices that define the permutations (not equivalent to LAPACK).
 *
 *******************************************************************************
 *
 * @return
 *          \retval MORSE_SUCCESS successful exit
 *          \retval <0 if -i, the i-th argument had an illegal value
 *          \retval >0 if i, U(i,i) is exactly zero. The factorization has been completed,
 *               but the factor U is exactly singular, and division by zero will occur
 *               if it is used to solve a system of equations.
 *
 *******************************************************************************
 *
 * @sa MORSE_zgetrf_incpiv_Tile
 * @sa MORSE_zgetrf_incpiv_Tile_Async
 * @sa MORSE_cgetrf_incpiv
 * @sa MORSE_dgetrf_incpiv
 * @sa MORSE_sgetrf_incpiv
 * @sa MORSE_zgetrs_incpiv
 *
 ******************************************************************************/
int MORSE_zgetrf_incpiv(int M, int N,
82
83
                        MORSE_Complex64_t *A, int LDA,
                        MORSE_desc_t *descL, int *IPIV)
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
{
    int NB;
    int status;
    MORSE_context_t *morse;
    MORSE_sequence_t *sequence = NULL;
    MORSE_request_t request = MORSE_REQUEST_INITIALIZER;
    MORSE_desc_t descA;

    morse = morse_context_self();
    if (morse == NULL) {
        morse_fatal_error("MORSE_zgetrf_incpiv", "MORSE not initialized");
        return MORSE_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (M < 0) {
        morse_error("MORSE_zgetrf_incpiv", "illegal value of M");
        return -1;
    }
    if (N < 0) {
        morse_error("MORSE_zgetrf_incpiv", "illegal value of N");
        return -2;
    }
106
    if (LDA < chameleon_max(1, M)) {
107
108
109
110
        morse_error("MORSE_zgetrf_incpiv", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
Mathieu Faverge's avatar
Mathieu Faverge committed
111
    if (chameleon_min(M, N) == 0)
112
113
114
115
116
117
118
119
120
121
122
123
124
125
        return MORSE_SUCCESS;

    /* Tune NB & IB depending on M, N & NRHS; Set NBNBSIZE */
    status = morse_tune(MORSE_FUNC_ZGESV, M, N, 0);
    if (status != MORSE_SUCCESS) {
        morse_error("MORSE_zgetrf_incpiv", "morse_tune() failed");
        return status;
    }

    /* Set NT & NTRHS */
    NB   = MORSE_NB;

    morse_sequence_create(morse, &sequence);

126
    /* Submit the matrix conversion */
127
128
    morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                     A, NB, NB, LDA, N, M, N, sequence, &request );
129
130
131
132

    /* Call the tile interface */
    MORSE_zgetrf_incpiv_Tile_Async(&descA, descL, IPIV, sequence, &request);

133
    /* Submit the matrix conversion */
Mathieu Faverge's avatar
Mathieu Faverge committed
134
135
136
    morse_ztile2lap( morse, &descAl, &descAt,
                     MorseUpperLower, sequence, &request );

137
    morse_sequence_wait(morse, sequence);
Mathieu Faverge's avatar
Mathieu Faverge committed
138

139
    morse_desc_mat_free(&descA);
140
141
142
143
144
145

    status = sequence->status;
    morse_sequence_destroy(morse, sequence);
    return status;
}

146
147
/**
 ********************************************************************************
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 *
 * @ingroup MORSE_Complex64_t_Tile
 *
 *  MORSE_zgetrf_incpiv_Tile - Computes the tile LU factorization of a matrix.
 *  Tile equivalent of MORSE_zgetrf_incpiv().
 *  Operates on matrices stored by tiles.
 *  All matrices are passed through descriptors.
 *  All dimensions are taken from the descriptors.
 *
 *******************************************************************************
 *
 * @param[in,out] A
 *          On entry, the M-by-N matrix to be factored.
 *          On exit, the tile factors L and U from the factorization.
 *
 * @param[out] L
 *          On exit, auxiliary factorization data, related to the tile L factor,
 *          required by MORSE_zgetrs_incpiv to solve the system of equations.
 *
 * @param[out] IPIV
 *          The pivot indices that define the permutations (not equivalent to LAPACK).
 *
 *******************************************************************************
 *
 * @return
 *          \retval MORSE_SUCCESS successful exit
 *          \retval >0 if i, U(i,i) is exactly zero. The factorization has been completed,
 *               but the factor U is exactly singular, and division by zero will occur
 *               if it is used to solve a system of equations.
 *
 *******************************************************************************
 *
 * @sa MORSE_zgetrf_incpiv
 * @sa MORSE_zgetrf_incpiv_Tile_Async
 * @sa MORSE_cgetrf_incpiv_Tile
 * @sa MORSE_dgetrf_incpiv_Tile
 * @sa MORSE_sgetrf_incpiv_Tile
 * @sa MORSE_zgetrs_incpiv_Tile
 *
 ******************************************************************************/
int MORSE_zgetrf_incpiv_Tile(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV)
{
    MORSE_context_t *morse;
    MORSE_sequence_t *sequence = NULL;
    MORSE_request_t request = MORSE_REQUEST_INITIALIZER;
    int status;

    morse = morse_context_self();
    if (morse == NULL) {
        morse_fatal_error("MORSE_zgetrf_incpiv_Tile", "MORSE not initialized");
        return MORSE_ERR_NOT_INITIALIZED;
    }
    morse_sequence_create(morse, &sequence);
    MORSE_zgetrf_incpiv_Tile_Async(A, L, IPIV, sequence, &request);
202
    RUNTIME_desc_flush( A, sequence );
Mathieu Faverge's avatar
Mathieu Faverge committed
203

Mathieu Faverge's avatar
Mathieu Faverge committed
204
    morse_sequence_wait(morse, sequence);
205

206
207
208
209
210
    status = sequence->status;
    morse_sequence_destroy(morse, sequence);
    return status;
}

211
212
/**
 ********************************************************************************
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 *
 * @ingroup MORSE_Complex64_t_Tile_Async
 *
 *  MORSE_zgetrf_incpiv_Tile_Async - Computes the tile LU factorization of a matrix.
 *  Non-blocking equivalent of MORSE_zgetrf_incpiv_Tile().
 *  May return before the computation is finished.
 *  Allows for pipelining of operations at runtime.
 *
 *******************************************************************************
 *
 * @param[in] sequence
 *          Identifies the sequence of function calls that this call belongs to
 *          (for completion checks and exception handling purposes).
 *
 * @param[out] request
 *          Identifies this function call (for exception handling purposes).
 *
 *******************************************************************************
 *
 * @sa MORSE_zgetrf_incpiv
 * @sa MORSE_zgetrf_incpiv_Tile
 * @sa MORSE_cgetrf_incpiv_Tile_Async
 * @sa MORSE_dgetrf_incpiv_Tile_Async
 * @sa MORSE_sgetrf_incpiv_Tile_Async
 * @sa MORSE_zgetrs_incpiv_Tile_Async
 *
 ******************************************************************************/
int MORSE_zgetrf_incpiv_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *L, int *IPIV,
241
                                   MORSE_sequence_t *sequence, MORSE_request_t *request)
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
{
    MORSE_context_t *morse;

    morse = morse_context_self();
    if (morse == NULL) {
        morse_fatal_error("MORSE_zgetrf_incpiv_Tile", "MORSE not initialized");
        return MORSE_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        morse_fatal_error("MORSE_zgetrf_incpiv_Tile", "NULL sequence");
        return MORSE_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        morse_fatal_error("MORSE_zgetrf_incpiv_Tile", "NULL request");
        return MORSE_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MORSE_SUCCESS)
        request->status = MORSE_SUCCESS;
    else
        return morse_request_fail(sequence, request, MORSE_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (morse_desc_check(A) != MORSE_SUCCESS) {
        morse_error("MORSE_zgetrf_incpiv_Tile", "invalid first descriptor");
        return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
    }
    if (morse_desc_check(L) != MORSE_SUCCESS) {
        morse_error("MORSE_zgetrf_incpiv_Tile", "invalid second descriptor");
        return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (A->nb != A->mb) {
        morse_error("MORSE_zgetrf_incpiv_Tile", "only square tiles supported");
        return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
279
280
281
282
    /*
     if (chameleon_min(M, N) == 0)
     return MORSE_SUCCESS;
     */
283
284
285
286
287

    morse_pzgetrf_incpiv(A, L, IPIV, sequence, request);

    return MORSE_SUCCESS;
}