3af4e4a6716493a81f566ada50c18218e574879d
[dense-linear-algebra-libraries/linalg.git] / src / ti / linalg / ticblas / src / ticblas.c
1 /******************************************************************************\r
2  * Copyright (c) 2015, Texas Instruments Incorporated - http://www.ti.com\r
3  *   All rights reserved.\r
4  *\r
5  *   Redistribution and use in source and binary forms, with or without\r
6  *   modification, are permitted provided that the following conditions are met:\r
7  *       * Redistributions of source code must retain the above copyright\r
8  *         notice, this list of conditions and the following disclaimer.\r
9  *       * Redistributions in binary form must reproduce the above copyright\r
10  *         notice, this list of conditions and the following disclaimer in the\r
11  *         documentation and/or other materials provided with the distribution.\r
12  *       * Neither the name of Texas Instruments Incorporated nor the\r
13  *         names of its contributors may be used to endorse or promote products\r
14  *         derived from this software without specific prior written permission.\r
15  *\r
16  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
17  *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
18  *   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
19  *   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
20  *   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
21  *   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
22  *   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
23  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
24  *   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
25  *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\r
26  *   THE POSSIBILITY OF SUCH DAMAGE.\r
27  *****************************************************************************/\r
28 #include <ti/libarch/libarch.h>\r
29 #include "../ticblas.h"\r
30 #include "blis.h"\r
31 \r
32 #define getNextMultiple(x, y) ( ( ((x)+(y)-1)/(y) )* (y) )\r
33 \r
34 #define BLAS_MEM_SIZE_VFAST (  getNextMultiple(BLIS_MK_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE) \\r
35                              + getNextMultiple(BLIS_KN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE) \\r
36                              + getNextMultiple(BLIS_MN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE) )\r
37 #define BLAS_MEM_SIZE_FAST  (  getNextMultiple(BLIS_MK_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE) \\r
38                              + getNextMultiple(BLIS_KN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE) \\r
39                              + getNextMultiple(BLIS_MN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE) )\r
40 #define BLAS_MEM_SIZE_MEDIUM ( getNextMultiple(BLIS_MK_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE) \\r
41                              + getNextMultiple(BLIS_KN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE) \\r
42                              + getNextMultiple(BLIS_MN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE) )\r
43 #define BLAS_MEM_SIZE_SLOW    (4804)\r
44 \r
45 /* Define memory descriptors for memory management */\r
46 lib_memdscr_t blas_mem_vfast;\r
47 lib_memdscr_t blas_mem_fast;\r
48 lib_memdscr_t blas_mem_medium;\r
49 lib_memdscr_t blas_mem_slow;\r
50 \r
51 /* Define a memory descriptor array */\r
52 lib_memdscr_t * blas_memdscr_tab[LIB_MEMTYPE_N] = {\r
53     &blas_mem_vfast,\r
54     &blas_mem_fast,\r
55     &blas_mem_medium,\r
56     &blas_mem_slow\r
57 };\r
58 \r
59 // note these pointers must be filled if used functions\r
60 char *pool_mk_mem_L1;\r
61 char *pool_kn_mem_L1;\r
62 char *pool_mn_mem_L1;\r
63 \r
64 char *pool_mk_mem_L2;\r
65 char *pool_kn_mem_L2;\r
66 char *pool_mn_mem_L2;\r
67 \r
68 char *pool_mk_mem_L3;\r
69 char *pool_kn_mem_L3;\r
70 char *pool_mn_mem_L3;\r
71 \r
72 extern void bli_mem_init();\r
73 \r
74 /*==============================================================================\r
75  * This function returns the address of the memory descriptor array\r
76  *============================================================================*/\r
77 void * blasGetMemHandle()\r
78 {\r
79     return((void *)&blas_memdscr_tab[0]);\r
80 } /* blasGetMemHandle */\r
81 \r
82 /*==============================================================================\r
83  *   It returns the size requirement of each of the 4 memory types defined in \r
84  *   the library framework. \r
85  *============================================================================*/\r
86 void tiCblasGetSizes(size_t *smem_size_vfast,  size_t *smem_size_fast, \r
87                      size_t *smem_size_medium, size_t *smem_size_slow)\r
88 {\r
89     *smem_size_vfast  = BLAS_MEM_SIZE_VFAST;  /* very fast scratch memory     */\r
90     *smem_size_fast   = BLAS_MEM_SIZE_FAST;   /* fast scratch memory          */\r
91     *smem_size_medium = BLAS_MEM_SIZE_MEDIUM; /* medium speed scratch memory  */ \r
92     *smem_size_slow   = BLAS_MEM_SIZE_SLOW;   /* slow scratch memory          */\r
93 /*\r
94     printf("BLIS_MK_POOL_SIZE_L1 is %d.\n", BLIS_MK_POOL_SIZE_L1);\r
95     printf("BLIS_KN_POOL_SIZE_L1 is %d.\n", BLIS_KN_POOL_SIZE_L1);\r
96     printf("BLIS_MN_POOL_SIZE_L1 is %d.\n", BLIS_MN_POOL_SIZE_L1);\r
97     printf("BLIS_MK_POOL_SIZE_L2 is %d.\n", BLIS_MK_POOL_SIZE_L2);\r
98     printf("BLIS_KN_POOL_SIZE_L2 is %d.\n", BLIS_KN_POOL_SIZE_L2);\r
99     printf("BLIS_MN_POOL_SIZE_L2 is %d.\n", BLIS_MN_POOL_SIZE_L2);\r
100     printf("BLIS_MK_POOL_SIZE_L3 is %d.\n", BLIS_MK_POOL_SIZE_L3);\r
101     printf("BLIS_KN_POOL_SIZE_L3 is %d.\n", BLIS_KN_POOL_SIZE_L3);\r
102     printf("BLIS_MN_POOL_SIZE_L3 is %d.\n", BLIS_MN_POOL_SIZE_L3);\r
103 */\r
104 } /* tiCblasGetSizes */\r
105 \r
106 /*==============================================================================\r
107  *   It performs necessary initialization through library framework API in order\r
108  *   to do memory allocations.  \r
109  *============================================================================*/\r
110 int tiCblasInit(void * mem_vfast_base,  size_t mem_vfast_size,\r
111                 void * mem_fast_base,   size_t mem_fast_size,\r
112                 void * mem_medium_base, size_t mem_medium_size,\r
113                 void * mem_slow_base,   size_t mem_slow_size)\r
114 {\r
115   lib_memdscr_t **blas_mem_handle = blasGetMemHandle();\r
116 \r
117   /* Verify supplied memories meet requirements */    \r
118   if(  ((mem_vfast_base  == NULL) || (mem_vfast_size  < BLAS_MEM_SIZE_VFAST)  )\r
119      ||((mem_fast_base   == NULL) || (mem_fast_size   < BLAS_MEM_SIZE_FAST)   )\r
120      ||((mem_medium_base == NULL) || (mem_medium_size < BLAS_MEM_SIZE_MEDIUM) )\r
121      ||((mem_slow_base   == NULL) || (mem_slow_size   < BLAS_MEM_SIZE_SLOW) )\r
122     ) {\r
123     return(TICBLAS_ERROR);\r
124   }\r
125   else {\r
126     lib_smem_vinit(blas_mem_handle, mem_vfast_base,  mem_vfast_size);\r
127     lib_smem_finit(blas_mem_handle, mem_fast_base,   mem_fast_size);\r
128     lib_smem_minit(blas_mem_handle, mem_medium_base, mem_medium_size);\r
129     lib_smem_sinit(blas_mem_handle, mem_slow_base,   mem_slow_size);      \r
130  \r
131     pool_mk_mem_L1 = lib_smem_valloc(blas_mem_handle, BLIS_MK_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE);\r
132     pool_kn_mem_L1 = lib_smem_valloc(blas_mem_handle, BLIS_KN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE);\r
133     pool_mn_mem_L1 = lib_smem_valloc(blas_mem_handle, BLIS_MN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE);\r
134 \r
135     pool_mk_mem_L2 = lib_smem_falloc(blas_mem_handle, BLIS_MK_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE);\r
136     pool_kn_mem_L2 = lib_smem_falloc(blas_mem_handle, BLIS_KN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE);\r
137     pool_mn_mem_L2 = lib_smem_falloc(blas_mem_handle, BLIS_MN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE);\r
138     \r
139     pool_mk_mem_L3 = lib_smem_malloc(blas_mem_handle, BLIS_MK_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE);\r
140     pool_kn_mem_L3 = lib_smem_malloc(blas_mem_handle, BLIS_KN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE);\r
141     pool_mn_mem_L3 = lib_smem_malloc(blas_mem_handle, BLIS_MN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE);\r
142 /*\r
143     printf("BLIS_MK_POOL_SIZE_L1 is %d, pool_mk_mem_L1 is 0x%x.\n", BLIS_MK_POOL_SIZE_L1, (unsigned int)pool_mk_mem_L1);\r
144     printf("BLIS_KN_POOL_SIZE_L1 is %d, pool_kn_mem_L1 is 0x%x.\n", BLIS_KN_POOL_SIZE_L1, (unsigned int)pool_kn_mem_L1);\r
145     printf("BLIS_MN_POOL_SIZE_L1 is %d, pool_mn_mem_L1 is 0x%x.\n", BLIS_MN_POOL_SIZE_L1, (unsigned int)pool_mn_mem_L1);\r
146     printf("BLIS_MK_POOL_SIZE_L2 is %d, pool_mk_mem_L2 is 0x%x.\n", BLIS_MK_POOL_SIZE_L2, (unsigned int)pool_mk_mem_L2);\r
147     printf("BLIS_KN_POOL_SIZE_L2 is %d, pool_kn_mem_L2 is 0x%x.\n", BLIS_KN_POOL_SIZE_L2, (unsigned int)pool_kn_mem_L2);\r
148     printf("BLIS_MN_POOL_SIZE_L2 is %d, pool_mn_mem_L2 is 0x%x.\n", BLIS_MN_POOL_SIZE_L2, (unsigned int)pool_mn_mem_L2);\r
149     printf("BLIS_MK_POOL_SIZE_L3 is %d, pool_mk_mem_L3 is 0x%x.\n", BLIS_MK_POOL_SIZE_L3, (unsigned int)pool_mk_mem_L3);\r
150     printf("BLIS_KN_POOL_SIZE_L3 is %d, pool_kn_mem_L3 is 0x%x.\n", BLIS_KN_POOL_SIZE_L3, (unsigned int)pool_kn_mem_L3);\r
151     printf("BLIS_MN_POOL_SIZE_L3 is %d, pool_mn_mem_L3 is 0x%x.\n", BLIS_MN_POOL_SIZE_L3, (unsigned int)pool_mn_mem_L3);\r
152 */  \r
153     if(  (pool_mk_mem_L1 == NULL)\r
154        ||(pool_kn_mem_L1 == NULL) \r
155        ||(pool_mn_mem_L1 == NULL)          \r
156        ||(pool_mk_mem_L2 == NULL) \r
157        ||(pool_kn_mem_L2 == NULL) \r
158        ||(pool_mn_mem_L2 == NULL)          \r
159        ||(pool_mk_mem_L3 == NULL) \r
160        ||(pool_kn_mem_L3 == NULL) \r
161        ||(pool_mn_mem_L3 == NULL) ) {\r
162       return(TICBLAS_ERROR);    \r
163     } \r
164     else {\r
165       bli_mem_init();\r
166       return(TICBLAS_SUCCESS);\r
167     }\r
168   }\r
169 } /* tiCblasInit */\r
170 \r
171 int tiCblasNew()\r
172 {\r
173   if(bli_init() == BLIS_SUCCESS) {\r
174     return(TICBLAS_SUCCESS);\r
175   }\r
176   else {\r
177     return(TICBLAS_ERROR);\r
178   }\r
179 }\r
180 \r
181 int tiCblasDelete()\r
182 {\r
183   if(bli_finalize() == BLIS_SUCCESS) {\r
184     return(TICBLAS_SUCCESS);\r
185   }\r
186   else {\r
187     return(TICBLAS_ERROR);\r
188   }\r
189 }\r
190 \r
191 /* Nothing after this line */\r