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 "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 #if 0\r
35 #ifdef MEM_MODEL_LARGE\r
36 #define BLAS_LEVEL3_L1DSRAM_SIZE (28*1024UL)\r
37 #define BLAS_LEVEL3_L2SRAM_SIZE (767*1024UL) /* 767KB */\r
38 #define BLAS_LEVEL3_MSMC_SIZE (0x47FDC0) /* 4.5MB */\r
39 #else\r
40 # ifdef MEM_MODEL_MEDIUM\r
41 # define BLAS_LEVEL3_L1DSRAM_SIZE (28*1024UL)\r
42 # define BLAS_LEVEL3_L2SRAM_SIZE (384*1024UL) /* 384KB */\r
43 # define BLAS_LEVEL3_MSMC_SIZE (0x380000) /* 3.5MB */\r
44 # else\r
45 # ifdef MEM_MODEL_SMALL\r
46 # define BLAS_LEVEL3_L1DSRAM_SIZE (18*1024UL)\r
47 # define BLAS_LEVEL3_L2SRAM_SIZE (183*1024UL) /* 187KB */\r
48 # define BLAS_LEVEL3_MSMC_SIZE (1520*1024UL)/* 1.5MB */\r
49 # else\r
50 # error "Unsupported memory model"\r
51 # endif\r
52 # endif\r
53 #endif\r
54 #endif\r
55 /*\r
56 #define BLAS_MEM_SIZE_VFAST BLAS_LEVEL3_L1DSRAM_SIZE \r
57 #define BLAS_MEM_SIZE_FAST BLAS_LEVEL3_L2SRAM_SIZE\r
58 #define BLAS_MEM_SIZE_MEDIUM BLAS_LEVEL3_MSMC_SIZE\r
59 */\r
60 #define BLAS_MEM_SIZE_VFAST ( getNextMultiple(BLIS_MK_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE) \\r
61 + getNextMultiple(BLIS_KN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE) \\r
62 + getNextMultiple(BLIS_MN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE) )\r
63 #define BLAS_MEM_SIZE_FAST ( getNextMultiple(BLIS_MK_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE) \\r
64 + getNextMultiple(BLIS_KN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE) \\r
65 + getNextMultiple(BLIS_MN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE) )\r
66 #define BLAS_MEM_SIZE_MEDIUM ( getNextMultiple(BLIS_MK_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE) \\r
67 + getNextMultiple(BLIS_KN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE) \\r
68 + getNextMultiple(BLIS_MN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE) )\r
69 #define BLAS_MEM_SIZE_SLOW (4804)\r
70 \r
71 /* Define memory descriptors for memory management */\r
72 lib_memdscr_t blas_mem_vfast;\r
73 lib_memdscr_t blas_mem_fast;\r
74 lib_memdscr_t blas_mem_medium;\r
75 lib_memdscr_t blas_mem_slow;\r
76 \r
77 /* Define a memory descriptor array */\r
78 lib_memdscr_t * blas_memdscr_tab[LIB_MEMTYPE_N] = {\r
79 &blas_mem_vfast,\r
80 &blas_mem_fast,\r
81 &blas_mem_medium,\r
82 &blas_mem_slow\r
83 };\r
84 \r
85 // note these pointers must be filled if used functions\r
86 char *pool_mk_mem_L1;\r
87 char *pool_kn_mem_L1;\r
88 char *pool_mn_mem_L1;\r
89 \r
90 char *pool_mk_mem_L2;\r
91 char *pool_kn_mem_L2;\r
92 char *pool_mn_mem_L2;\r
93 \r
94 char *pool_mk_mem_L3;\r
95 char *pool_kn_mem_L3;\r
96 char *pool_mn_mem_L3;\r
97 \r
98 extern void bli_mem_init();\r
99 \r
100 /*==============================================================================\r
101 * This function returns the address of the memory descriptor array\r
102 *============================================================================*/\r
103 void * blasGetMemHandle()\r
104 {\r
105 return((void *)&blas_memdscr_tab[0]);\r
106 } /* blasGetMemHandle */\r
107 \r
108 /*==============================================================================\r
109 * It returns the size requirement of each of the 4 memory types defined in \r
110 * the library framework. \r
111 *============================================================================*/\r
112 void tiCblasGetSizes(size_t *smem_size_vfast, size_t *smem_size_fast, \r
113 size_t *smem_size_medium, size_t *smem_size_slow)\r
114 {\r
115 *smem_size_vfast = BLAS_MEM_SIZE_VFAST; // very fast scratch memory\r
116 *smem_size_fast = BLAS_MEM_SIZE_FAST; // fast scratch memory\r
117 *smem_size_medium = BLAS_MEM_SIZE_MEDIUM; // medium speed scratch memory\r
118 *smem_size_slow = BLAS_MEM_SIZE_SLOW; // slow scratch memory\r
119 /*\r
120 printf("BLIS_MK_POOL_SIZE_L1 is %d.\n", BLIS_MK_POOL_SIZE_L1);\r
121 printf("BLIS_KN_POOL_SIZE_L1 is %d.\n", BLIS_KN_POOL_SIZE_L1);\r
122 printf("BLIS_MN_POOL_SIZE_L1 is %d.\n", BLIS_MN_POOL_SIZE_L1);\r
123 printf("BLIS_MK_POOL_SIZE_L2 is %d.\n", BLIS_MK_POOL_SIZE_L2);\r
124 printf("BLIS_KN_POOL_SIZE_L2 is %d.\n", BLIS_KN_POOL_SIZE_L2);\r
125 printf("BLIS_MN_POOL_SIZE_L2 is %d.\n", BLIS_MN_POOL_SIZE_L2);\r
126 printf("BLIS_MK_POOL_SIZE_L3 is %d.\n", BLIS_MK_POOL_SIZE_L3);\r
127 printf("BLIS_KN_POOL_SIZE_L3 is %d.\n", BLIS_KN_POOL_SIZE_L3);\r
128 printf("BLIS_MN_POOL_SIZE_L3 is %d.\n", BLIS_MN_POOL_SIZE_L3);\r
129 */\r
130 } /* tiCblasGetSizes */\r
131 \r
132 /*==============================================================================\r
133 * It performs necessary initialization through library framework API in order\r
134 * to do memory allocations. \r
135 *============================================================================*/\r
136 int tiCblasInit(void * mem_vfast_base, size_t mem_vfast_size,\r
137 void * mem_fast_base, size_t mem_fast_size,\r
138 void * mem_medium_base, size_t mem_medium_size,\r
139 void * mem_slow_base, size_t mem_slow_size)\r
140 {\r
141 lib_memdscr_t **blas_mem_handle = blasGetMemHandle();\r
142 \r
143 /* Verify supplied memories meet requirements */ \r
144 if( ((mem_vfast_base == NULL) || (mem_vfast_size < BLAS_MEM_SIZE_VFAST) )\r
145 ||((mem_fast_base == NULL) || (mem_fast_size < BLAS_MEM_SIZE_FAST) )\r
146 ||((mem_medium_base == NULL) || (mem_medium_size < BLAS_MEM_SIZE_MEDIUM) )\r
147 ||((mem_slow_base == NULL) || (mem_slow_size < BLAS_MEM_SIZE_SLOW) )\r
148 ) {\r
149 return(TICBLAS_ERROR);\r
150 }\r
151 else {\r
152 lib_smem_vinit(blas_mem_handle, mem_vfast_base, mem_vfast_size);\r
153 lib_smem_finit(blas_mem_handle, mem_fast_base, mem_fast_size);\r
154 lib_smem_minit(blas_mem_handle, mem_medium_base, mem_medium_size);\r
155 lib_smem_sinit(blas_mem_handle, mem_slow_base, mem_slow_size); \r
156 \r
157 pool_mk_mem_L1 = lib_smem_valloc(blas_mem_handle, BLIS_MK_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE);\r
158 pool_kn_mem_L1 = lib_smem_valloc(blas_mem_handle, BLIS_KN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE);\r
159 pool_mn_mem_L1 = lib_smem_valloc(blas_mem_handle, BLIS_MN_POOL_SIZE_L1, BLIS_CACHE_LINE_SIZE);\r
160 \r
161 pool_mk_mem_L2 = lib_smem_falloc(blas_mem_handle, BLIS_MK_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE);\r
162 pool_kn_mem_L2 = lib_smem_falloc(blas_mem_handle, BLIS_KN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE);\r
163 pool_mn_mem_L2 = lib_smem_falloc(blas_mem_handle, BLIS_MN_POOL_SIZE_L2, BLIS_CACHE_LINE_SIZE);\r
164 \r
165 pool_mk_mem_L3 = lib_smem_malloc(blas_mem_handle, BLIS_MK_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE);\r
166 pool_kn_mem_L3 = lib_smem_malloc(blas_mem_handle, BLIS_KN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE);\r
167 pool_mn_mem_L3 = lib_smem_malloc(blas_mem_handle, BLIS_MN_POOL_SIZE_L3, BLIS_CACHE_LINE_SIZE);\r
168 /*\r
169 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
170 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
171 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
172 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
173 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
174 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
175 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
176 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
177 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
178 */ \r
179 if( (pool_mk_mem_L1 == NULL)\r
180 ||(pool_kn_mem_L1 == NULL) \r
181 ||(pool_mn_mem_L1 == NULL) \r
182 ||(pool_mk_mem_L2 == NULL) \r
183 ||(pool_kn_mem_L2 == NULL) \r
184 ||(pool_mn_mem_L2 == NULL) \r
185 ||(pool_mk_mem_L3 == NULL) \r
186 ||(pool_kn_mem_L3 == NULL) \r
187 ||(pool_mn_mem_L3 == NULL) ) {\r
188 return(TICBLAS_ERROR); \r
189 } \r
190 else {\r
191 bli_mem_init();\r
192 return(TICBLAS_SUCCESS);\r
193 }\r
194 }\r
195 } /* tiCblasInit */\r
196 \r
197 int tiCblasNew()\r
198 {\r
199 if(bli_init() == BLIS_SUCCESS) {\r
200 return(TICBLAS_SUCCESS);\r
201 }\r
202 else {\r
203 return(TICBLAS_ERROR);\r
204 }\r
205 }\r
206 \r
207 int tiCblasDelete()\r
208 {\r
209 if(bli_finalize() == BLIS_SUCCESS) {\r
210 return(TICBLAS_SUCCESS);\r
211 }\r
212 else {\r
213 return(TICBLAS_ERROR);\r
214 }\r
215 }\r
216 \r
217 /* Nothing after this line */\r