zgelqf.c 9.42 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
30
 *
 **/

/**
 *
 * @file zgelqf.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 Dulceneia Becker
 * @author Mathieu Faverge
 * @author Emmanuel Agullo
 * @author Cedric Castagnede
 * @date 2010-11-15
 * @precisions normal z -> s d c
 *
 **/
31
#include "control/common.h"
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
 *
 * @ingroup MORSE_Complex64_t
 *
 *  MORSE_zgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.
 *
 *******************************************************************************
 *
 * @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 A.
 *          On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N)
 *          lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the
 *          diagonal represent the unitary matrix Q as a product of elementary reflectors, stored
 *          by tiles.
 *
 * @param[in] LDA
 *          The leading dimension of the array A. LDA >= max(1,M).
 *
 * @param[out] descT
 *          On exit, auxiliary factorization data, required by MORSE_zgelqs to solve the system
 *          of equations.
 *
 *******************************************************************************
 *
 * @return
 *          \retval MORSE_SUCCESS successful exit
 *          \retval <0 if -i, the i-th argument had an illegal value
 *
 *******************************************************************************
 *
 * @sa MORSE_zgelqf_Tile
 * @sa MORSE_zgelqf_Tile_Async
 * @sa MORSE_cgelqf
 * @sa MORSE_dgelqf
 * @sa MORSE_sgelqf
 * @sa MORSE_zgelqs
 *
 ******************************************************************************/
int MORSE_zgelqf(int M, int N,
79
80
                 MORSE_Complex64_t *A, int LDA,
                 MORSE_desc_t *descT)
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
{
    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_zgelqf", "MORSE not initialized");
        return MORSE_ERR_NOT_INITIALIZED;
    }

    /* Check input arguments */
    if (M < 0) {
        morse_error("MORSE_zgelqf", "illegal value of M");
        return -1;
    }
    if (N < 0) {
        morse_error("MORSE_zgelqf", "illegal value of N");
        return -2;
    }
104
    if (LDA < chameleon_max(1, M)) {
105
106
107
108
109
        morse_error("MORSE_zgelqf", "illegal value of LDA");
        return -4;
    }

    /* Quick return */
Mathieu Faverge's avatar
Mathieu Faverge committed
110
    if (chameleon_min(M, N) == 0)
111
112
113
114
115
116
117
118
119
120
121
122
123
        return MORSE_SUCCESS;

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

    /* Set NT */
    NB = MORSE_NB;

    morse_sequence_create(morse, &sequence);
Mathieu Faverge's avatar
Mathieu Faverge committed
124

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

    /* Call the tile interface */
    MORSE_zgelqf_Tile_Async(&descA, descT, sequence, &request);

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

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

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

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

145
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
 *
 * @ingroup MORSE_Complex64_t_Tile
 *
 *  MORSE_zgelqf_Tile - Computes the tile LQ factorization of a matrix.
 *  Tile equivalent of MORSE_zgelqf().
 *  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 A.
 *          On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N)
 *          lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the
 *          diagonal represent the unitary matrix Q as a product of elementary reflectors, stored
 *          by tiles.
 *
 * @param[out] T
 *          On exit, auxiliary factorization data, required by MORSE_zgelqs to solve the system
 *          of equations.
 *
 *******************************************************************************
 *
 * @return
 *          \retval MORSE_SUCCESS successful exit
 *
 *******************************************************************************
 *
 * @sa MORSE_zgelqf
 * @sa MORSE_zgelqf_Tile_Async
 * @sa MORSE_cgelqf_Tile
 * @sa MORSE_dgelqf_Tile
 * @sa MORSE_sgelqf_Tile
 * @sa MORSE_zgelqs_Tile
 *
 ******************************************************************************/
int MORSE_zgelqf_Tile(MORSE_desc_t *A, MORSE_desc_t *T)
{
    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_zgelqf_Tile", "MORSE not initialized");
        return MORSE_ERR_NOT_INITIALIZED;
    }
    morse_sequence_create(morse, &sequence);
    MORSE_zgelqf_Tile_Async(A, T, sequence, &request);
198
    RUNTIME_desc_flush( A, sequence );
Mathieu Faverge's avatar
Mathieu Faverge committed
199

Mathieu Faverge's avatar
Mathieu Faverge committed
200
    morse_sequence_wait(morse, sequence);
Mathieu Faverge's avatar
Mathieu Faverge committed
201

202
203
204
205
206
    status = sequence->status;
    morse_sequence_destroy(morse, sequence);
    return status;
}

207
208
/**
 ********************************************************************************
209
210
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
 *
 * @ingroup MORSE_Complex64_t_Tile_Async
 *
 *  MORSE_zgelqf_Tile_Async - Computes the tile LQ factorization of a matrix.
 *  Non-blocking equivalent of MORSE_zgelqf_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_zgelqf
 * @sa MORSE_zgelqf_Tile
 * @sa MORSE_cgelqf_Tile_Async
 * @sa MORSE_dgelqf_Tile_Async
 * @sa MORSE_sgelqf_Tile_Async
 * @sa MORSE_zgelqs_Tile_Async
 *
 ******************************************************************************/
int MORSE_zgelqf_Tile_Async(MORSE_desc_t *A, MORSE_desc_t *T,
237
                            MORSE_sequence_t *sequence, MORSE_request_t *request)
238
239
{
    MORSE_context_t *morse;
240
    MORSE_desc_t D, *Dptr = NULL;
241
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

    morse = morse_context_self();
    if (morse == NULL) {
        morse_fatal_error("MORSE_zgelqf_Tile", "MORSE not initialized");
        return MORSE_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        morse_fatal_error("MORSE_zgelqf_Tile", "NULL sequence");
        return MORSE_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        morse_fatal_error("MORSE_zgelqf_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_zgelqf_Tile", "invalid first descriptor");
        return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
    }
    if (morse_desc_check(T) != MORSE_SUCCESS) {
        morse_error("MORSE_zgelqf_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_zgelqf_Tile", "only square tiles supported");
        return morse_request_fail(sequence, request, MORSE_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
276
277
278
279
    /*
     if (chameleon_min(M, N) == 0)
     return MORSE_SUCCESS;
     */
280
281
282
283
284
285
286
287
#if defined(CHAMELEON_COPY_DIAG)
    {
        int m = chameleon_min(A->mt, A->nt) * A->mb;
        morse_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
        Dptr = &D;
    }
#endif

288
    if (morse->householder == MORSE_FLAT_HOUSEHOLDER) {
289
        morse_pzgelqf(A, T, Dptr, sequence, request);
290
291
    }
    else {
292
        morse_pzgelqfrh(A, T, Dptr, MORSE_RHBLK, sequence, request);
293
    }
294
295
296
297
    if (Dptr != NULL) {
        morse_desc_mat_free(Dptr);
    }
    (void)D;
298
299
    return MORSE_SUCCESS;
}