1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi/native_api.h"
17 #include "native_common.h"
18 #include "cstdlib"
19 #include <js_native_api_types.h>
20 #include <purgeable_memory/purgeable_memory.h>
21
22 struct ParaData {
23 int start;
24 int end;
25 };
FactorialFunc(void * data,size_t,void * param)26 bool FactorialFunc(void *data, size_t, void *param)
27 {
28 bool ret = true;
29 ParaData *pData = (ParaData *)param;
30 int *oriData = (int *)data;
31 int i = pData->start;
32 while (i < pData->end) {
33 *oriData *= i;
34 i++;
35 }
36 return ret;
37 }
38 struct AppendParaData {
39 int newPara;
40 };
41 #define DATASIZE (4 * 1024 * 1024)
42 #define DATASIZENULL (0 * 1024 * 1024)
43 struct ParaData g_pData = {1, 2};
44
AddFunc(void * data,size_t,void * param)45 bool AddFunc(void *data, size_t, void *param)
46 {
47 bool ret = true;
48 int *oriDaTap = (int *)data;
49 AppendParaData *apData = (AppendParaData *)param;
50 *oriDaTap += apData->newPara;
51 return ret;
52 }
53
CreateOne(napi_env env,napi_callback_info)54 static napi_value CreateOne(napi_env env, napi_callback_info)
55 {
56 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
57 napi_value result = nullptr;
58 napi_create_int32(env, res != nullptr, &result);
59 OH_PurgeableMemory_Destroy(res);
60 res = nullptr;
61 return result;
62 }
63
CreateTwo(napi_env env,napi_callback_info)64 static napi_value CreateTwo(napi_env env, napi_callback_info)
65 {
66 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZENULL, FactorialFunc, &g_pData);
67 napi_value result = nullptr;
68 napi_create_int32(env, res == nullptr, &result);
69 OH_PurgeableMemory_Destroy(res);
70 res = nullptr;
71 return result;
72 }
73
DestroyOne(napi_env env,napi_callback_info)74 static napi_value DestroyOne(napi_env env, napi_callback_info)
75 {
76 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
77 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
78 bool ret = OH_PurgeableMemory_Destroy(res);
79 res = nullptr;
80 napi_value result = nullptr;
81 napi_create_int32(env, ret, &result);
82 return result;
83 }
84
DestroyTwo(napi_env env,napi_callback_info)85 static napi_value DestroyTwo(napi_env env, napi_callback_info)
86 {
87 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
88 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
89 bool ret = OH_PurgeableMemory_Destroy(res);
90 res = nullptr;
91 NAPI_ASSERT(env, ret == true, "OH_PurgeAbleMemory_Destroy failed");
92 class ReqObj;
93 ReqObj *pReqObj = (ReqObj *)OH_PurgeableMemory_GetContent(res);
94 napi_value result = nullptr;
95 napi_create_int32(env, pReqObj == nullptr, &result);
96 return result;
97 }
98
DestroyThree(napi_env env,napi_callback_info)99 static napi_value DestroyThree(napi_env env, napi_callback_info)
100 {
101 OH_PurgeableMemory *res = nullptr;
102 bool ret = OH_PurgeableMemory_Destroy(res);
103 res = nullptr;
104 napi_value result = nullptr;
105 napi_create_int32(env, ret, &result);
106 return result;
107 }
108
BeginReadOne(napi_env env,napi_callback_info)109 static napi_value BeginReadOne(napi_env env, napi_callback_info)
110 {
111 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
112 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
113 bool ret = OH_PurgeableMemory_BeginRead(res);
114 if (ret) {
115 OH_PurgeableMemory_EndRead(res);
116 }
117 OH_PurgeableMemory_Destroy(res);
118 res = nullptr;
119 napi_value result = nullptr;
120 napi_create_int32(env, ret, &result);
121 return result;
122 }
123
BeginReadTwo(napi_env env,napi_callback_info)124 static napi_value BeginReadTwo(napi_env env, napi_callback_info)
125 {
126 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
127 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
128 bool destoryValue = OH_PurgeableMemory_Destroy(res);
129 NAPI_ASSERT(env, destoryValue == true, "OH_PurgeableMemory_Destroy failed");
130 res = nullptr;
131 bool ret = OH_PurgeableMemory_BeginRead(res);
132 napi_value result = nullptr;
133 napi_create_int32(env, ret, &result);
134 return result;
135 }
136
EndRead(napi_env env,napi_callback_info)137 static napi_value EndRead(napi_env env, napi_callback_info)
138 {
139 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
140 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
141 bool beginReadValue = OH_PurgeableMemory_BeginRead(res);
142 NAPI_ASSERT(env, beginReadValue == true, "OH_PurgeAbleMemory_BeginRead failed");
143 OH_PurgeableMemory_EndRead(res);
144 OH_PurgeableMemory_Destroy(res);
145 res = nullptr;
146 napi_value result = nullptr;
147 napi_create_int32(env, true, &result);
148 return result;
149 }
150
BeginWriteOne(napi_env env,napi_callback_info)151 static napi_value BeginWriteOne(napi_env env, napi_callback_info)
152 {
153 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
154 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
155 bool ret = OH_PurgeableMemory_BeginWrite(res);
156 if (ret) {
157 OH_PurgeableMemory_EndWrite(res);
158 }
159 napi_value result = nullptr;
160 napi_create_int32(env, ret, &result);
161 OH_PurgeableMemory_Destroy(res);
162 res = nullptr;
163 return result;
164 }
165
BeginWriteTwo(napi_env env,napi_callback_info)166 static napi_value BeginWriteTwo(napi_env env, napi_callback_info)
167 {
168 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
169 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
170 bool destoryValue = OH_PurgeableMemory_Destroy(res);
171 NAPI_ASSERT(env, destoryValue == true, "OH_PurgeableMemory_Destroy failed");
172 res = nullptr;
173 bool ret = OH_PurgeableMemory_BeginWrite(res);
174 napi_value result = nullptr;
175 napi_create_int32(env, ret, &result);
176 return result;
177 }
178
EndWrite(napi_env env,napi_callback_info)179 static napi_value EndWrite(napi_env env, napi_callback_info)
180 {
181 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
182 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
183 bool beginWriteValue = OH_PurgeableMemory_BeginWrite(res);
184 NAPI_ASSERT(env, beginWriteValue == true, "OH_PurgeAbleMemory_Create failed");
185 OH_PurgeableMemory_EndWrite(res);
186 struct AppendParaData apData = {1};
187 bool ret = OH_PurgeableMemory_AppendModify(res, AddFunc, &apData);
188 OH_PurgeableMemory_Destroy(res);
189 res = nullptr;
190 napi_value result = nullptr;
191 napi_create_int32(env, ret, &result);
192 return result;
193 }
194
GetContentOne(napi_env env,napi_callback_info)195 static napi_value GetContentOne(napi_env env, napi_callback_info)
196 {
197 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
198 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
199 bool beginReadValue = OH_PurgeableMemory_BeginRead(res);
200 NAPI_ASSERT(env, beginReadValue == true, "OH_PurgeAbleMemory_Create failed");
201 class ReqObj;
202 ReqObj *pReqObj = (ReqObj *)OH_PurgeableMemory_GetContent(res);
203 napi_value result = nullptr;
204 napi_create_int32(env, pReqObj != nullptr, &result);
205 OH_PurgeableMemory_EndRead(res);
206 OH_PurgeableMemory_Destroy(res);
207 res = nullptr;
208 return result;
209 }
210
GetContentTwo(napi_env env,napi_callback_info)211 static napi_value GetContentTwo(napi_env env, napi_callback_info)
212 {
213 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
214 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
215 bool desotoryValue = OH_PurgeableMemory_Destroy(res);
216 NAPI_ASSERT(env, desotoryValue == true, "OH_PurgeableMemory_Destroy failed");
217 res = nullptr;
218 class ReqObj;
219 ReqObj *pReqObj = (ReqObj *)OH_PurgeableMemory_GetContent(res);
220 napi_value result = nullptr;
221 napi_create_int32(env, pReqObj == nullptr, &result);
222
223 return result;
224 }
225
ContentSizeOne(napi_env env,napi_callback_info)226 static napi_value ContentSizeOne(napi_env env, napi_callback_info)
227 {
228 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
229 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
230 bool beginReadValue = OH_PurgeableMemory_BeginRead(res);
231 NAPI_ASSERT(env, beginReadValue == true, "OH_PurgeAbleMemory_BeginRead failed");
232 size_t size = OH_PurgeableMemory_ContentSize(res);
233 napi_value result = nullptr;
234 napi_create_int32(env, size != 0, &result);
235 OH_PurgeableMemory_EndRead(res);
236 OH_PurgeableMemory_Destroy(res);
237 res = nullptr;
238 return result;
239 }
240
ContentSizeTwo(napi_env env,napi_callback_info)241 static napi_value ContentSizeTwo(napi_env env, napi_callback_info)
242 {
243 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
244 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
245 size_t size = OH_PurgeableMemory_ContentSize(res);
246 napi_value result = nullptr;
247 napi_create_int32(env, size == 0, &result);
248 OH_PurgeableMemory_Destroy(res);
249 res = nullptr;
250 return result;
251 }
252
AppendModifyOne(napi_env env,napi_callback_info)253 static napi_value AppendModifyOne(napi_env env, napi_callback_info)
254 {
255 OH_PurgeableMemory *res = OH_PurgeableMemory_Create(DATASIZE, FactorialFunc, &g_pData);
256 NAPI_ASSERT(env, res != nullptr, "OH_PurgeAbleMemory_Create failed");
257 bool beginWriteValue = OH_PurgeableMemory_BeginWrite(res);
258 NAPI_ASSERT(env, beginWriteValue == true, "OH_PurgeAbleMemory_Create failed");
259 struct AppendParaData apData = {1};
260 bool ret = OH_PurgeableMemory_AppendModify(res, AddFunc, &apData);
261 OH_PurgeableMemory_EndWrite(res);
262 OH_PurgeableMemory_Destroy(res);
263 res = nullptr;
264 napi_value result = nullptr;
265 napi_create_int32(env, ret, &result);
266 return result;
267 }
268
AppendModifyTwo(napi_env env,napi_callback_info)269 static napi_value AppendModifyTwo(napi_env env, napi_callback_info)
270 {
271 OH_PurgeableMemory *res = nullptr;
272 struct AppendParaData apData = {1};
273 bool ret = OH_PurgeableMemory_AppendModify(res, AddFunc, &apData);
274 napi_value result = nullptr;
275 napi_create_int32(env, ret, &result);
276 return result;
277 }
278
279 EXTERN_C_START
Init(napi_env env,napi_value exports)280 static napi_value Init(napi_env env, napi_value exports)
281 {
282 napi_property_descriptor desc[] = {
283 {"createOne", nullptr, CreateOne, nullptr, nullptr, nullptr, napi_default, nullptr},
284 {"createTwo", nullptr, CreateTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
285 {"destroyOne", nullptr, DestroyOne, nullptr, nullptr, nullptr, napi_default, nullptr},
286 {"destroyTwo", nullptr, DestroyTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
287 {"destroyThree", nullptr, DestroyThree, nullptr, nullptr, nullptr, napi_default, nullptr},
288 {"beginReadOne", nullptr, BeginReadOne, nullptr, nullptr, nullptr, napi_default, nullptr},
289 {"beginReadTwo", nullptr, BeginReadTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
290 {"endRead", nullptr, EndRead, nullptr, nullptr, nullptr, napi_default, nullptr},
291 {"beginWriteOne", nullptr, BeginWriteOne, nullptr, nullptr, nullptr, napi_default, nullptr},
292 {"beginWriteTwo", nullptr, BeginWriteTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
293 {"endWrite", nullptr, EndWrite, nullptr, nullptr, nullptr, napi_default, nullptr},
294 {"getContentOne", nullptr, GetContentOne, nullptr, nullptr, nullptr, napi_default, nullptr},
295 {"getContentTwo", nullptr, GetContentTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
296 {"contentSizeOne", nullptr, ContentSizeOne, nullptr, nullptr, nullptr, napi_default, nullptr},
297 {"contentSizeTwo", nullptr, ContentSizeTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
298 {"appendModifyOne", nullptr, AppendModifyOne, nullptr, nullptr, nullptr, napi_default, nullptr},
299 {"appendModifyTwo", nullptr, AppendModifyTwo, nullptr, nullptr, nullptr, napi_default, nullptr},
300 };
301 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
302 return exports;
303 }
304 EXTERN_C_END
305
306 static napi_module demoModule = {
307 .nm_version = 1,
308 .nm_flags = 0,
309 .nm_filename = nullptr,
310 .nm_register_func = Init,
311 .nm_modname = "libmemory",
312 .nm_priv = ((void *)0),
313 .reserved = {0},
314 };
315
RegisterEntryModule(void)316 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
317