disk_copy_to_disk.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412
  1. /* StarPU --- Runtime system for heterogeneous multicore architectures.
  2. *
  3. * Copyright (C) 2017 Inria
  4. *
  5. * StarPU is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU Lesser General Public License as published by
  7. * the Free Software Foundation; either version 2.1 of the License, or (at
  8. * your option) any later version.
  9. *
  10. * StarPU is distributed in the hope that it will be useful, but
  11. * WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13. *
  14. * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  15. */
  16. #include <fcntl.h>
  17. #include <starpu.h>
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. #include <unistd.h>
  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #include <unistd.h>
  24. #include <math.h>
  25. #include <common/config.h>
  26. #include "../helper.h"
  27. #ifdef STARPU_HAVE_HDF5
  28. #include <hdf5.h>
  29. #endif
  30. /*
  31. * Try to write into disk memory
  32. * Use mechanism to push data from disk to disk.
  33. */
  34. #define NX (16*1024)
  35. int dotest(struct starpu_disk_ops *ops, char *base)
  36. {
  37. int *A, *C;
  38. /* Initialize StarPU with default configuration */
  39. int ret = starpu_init(NULL);
  40. if (ret == -ENODEV) goto enodev;
  41. /* Initialize path and name */
  42. const char *name_file_start = "STARPU_DISK_COMPUTE_DATA";
  43. const char *name_dir_src = "src";
  44. const char *name_dir_dst = "dst";
  45. char * path_file_start = malloc(strlen(base) + 1 + strlen(name_dir_src) + 1 + strlen(name_file_start) + 1);
  46. strcpy(path_file_start, base);
  47. strcat(path_file_start, "/");
  48. strcat(path_file_start, name_dir_src);
  49. strcat(path_file_start, "/");
  50. strcat(path_file_start, name_file_start);
  51. char * base_src = malloc(strlen(base) + 1 + strlen(name_dir_src) + 1);
  52. strcpy(base_src, base);
  53. strcat(base_src, "/");
  54. strcat(base_src, name_dir_src);
  55. char * base_dst = malloc(strlen(base) + 1 + strlen(name_dir_dst) + 1);
  56. strcpy(base_dst, base);
  57. strcat(base_dst, "/");
  58. strcat(base_dst, name_dir_dst);
  59. /* register a disks */
  60. int disk_src = starpu_disk_register(ops, (void *) base_src, STARPU_DISK_SIZE_MIN);
  61. if (disk_src == -ENOENT) goto enoent;
  62. int disk_dst = starpu_disk_register(ops, (void *) base_dst, STARPU_DISK_SIZE_MIN);
  63. if (disk_dst == -ENOENT) goto enoent;
  64. /* allocate two memory spaces */
  65. starpu_malloc_flags((void **)&A, NX*sizeof(int), STARPU_MALLOC_COUNT);
  66. starpu_malloc_flags((void **)&C, NX*sizeof(int), STARPU_MALLOC_COUNT);
  67. FPRINTF(stderr, "TEST DISK MEMORY \n");
  68. unsigned int j;
  69. /* you register them in a vector */
  70. for(j = 0; j < NX; ++j)
  71. {
  72. A[j] = j;
  73. C[j] = 0;
  74. }
  75. /* you create a file to store the vector ON the disk */
  76. FILE * f = fopen(path_file_start, "wb+");
  77. if (f == NULL)
  78. goto enoent2;
  79. /* store it in the file */
  80. fwrite(A, sizeof(int), NX, f);
  81. /* close the file */
  82. fclose(f);
  83. int descriptor = open(path_file_start, O_RDWR);
  84. if (descriptor < 0)
  85. goto enoent2;
  86. #ifdef STARPU_HAVE_WINDOWS
  87. _commit(descriptor);
  88. #else
  89. fsync(descriptor);
  90. #endif
  91. close(descriptor);
  92. /* And now, you want to use your datas in StarPU */
  93. /* Open the file ON the disk */
  94. void * data = starpu_disk_open(disk_src, (void *) name_file_start, NX*sizeof(int));
  95. starpu_data_handle_t vector_handleA;
  96. starpu_vector_data_register(&vector_handleA, disk_src, (uintptr_t) data, NX, sizeof(int));
  97. /* Move and invalidate copy to an other disk */
  98. starpu_data_acquire_on_node(vector_handleA, disk_dst, STARPU_RW);
  99. starpu_data_release_on_node(vector_handleA, disk_dst);
  100. starpu_data_acquire_on_node(vector_handleA, disk_src, STARPU_RW);
  101. starpu_data_release_on_node(vector_handleA, disk_src);
  102. /* free them */
  103. starpu_data_unregister(vector_handleA);
  104. /* close them in StarPU */
  105. starpu_disk_close(disk_src, data, NX*sizeof(int));
  106. /* check results */
  107. f = fopen(path_file_start, "rb+");
  108. if (f == NULL)
  109. goto enoent2;
  110. /* take datas */
  111. size_t read = fread(C, sizeof(int), NX, f);
  112. STARPU_ASSERT(read == NX);
  113. /* close the file */
  114. fclose(f);
  115. int try = 1;
  116. for (j = 0; j < NX; ++j)
  117. if (A[j] != C[j])
  118. {
  119. FPRINTF(stderr, "Fail A %d != C %d \n", A[j], C[j]);
  120. try = 0;
  121. }
  122. starpu_free_flags(A, NX*sizeof(int), STARPU_MALLOC_COUNT);
  123. starpu_free_flags(C, NX*sizeof(int), STARPU_MALLOC_COUNT);
  124. /* terminate StarPU, no task can be submitted after */
  125. starpu_shutdown();
  126. unlink(path_file_start);
  127. rmdir(base_src);
  128. free(base_src);
  129. free(base_dst);
  130. free(path_file_start);
  131. if(try)
  132. FPRINTF(stderr, "TEST SUCCESS\n");
  133. else
  134. FPRINTF(stderr, "TEST FAIL\n");
  135. return try ? EXIT_SUCCESS : EXIT_FAILURE;
  136. enodev:
  137. return STARPU_TEST_SKIPPED;
  138. enoent2:
  139. starpu_free_flags(A, NX*sizeof(int), STARPU_MALLOC_COUNT);
  140. starpu_free_flags(C, NX*sizeof(int), STARPU_MALLOC_COUNT);
  141. enoent:
  142. free(base_src);
  143. free(base_dst);
  144. free(path_file_start);
  145. FPRINTF(stderr, "Couldn't write data: ENOENT\n");
  146. starpu_shutdown();
  147. return STARPU_TEST_SKIPPED;
  148. }
  149. #ifdef STARPU_HAVE_HDF5
  150. int dotest_hdf5(struct starpu_disk_ops *ops, char *base)
  151. {
  152. int *A, *C;
  153. herr_t status;
  154. /* Initialize path */
  155. const char *path_obj_start = "STARPU_DISK_COMPUTE_DATA";
  156. const char *name_hdf5_start = "STARPU_HDF5_src_file.h5";
  157. const char *name_hdf5_end = "STARPU_HDF5_dst_file.h5";
  158. char * hdf5_base_src = malloc(strlen(base) + 1 + strlen(name_hdf5_start) + 1);
  159. strcpy(hdf5_base_src, base);
  160. strcat(hdf5_base_src, "/");
  161. strcat(hdf5_base_src, name_hdf5_start);
  162. char * hdf5_base_dst = malloc(strlen(base) + 1 + strlen(name_hdf5_end) + 1);
  163. strcpy(hdf5_base_dst, base);
  164. strcat(hdf5_base_dst, "/");
  165. strcat(hdf5_base_dst, name_hdf5_end);
  166. /* Open and close files, just to create empty files */
  167. FILE * file_src = fopen(hdf5_base_src, "wb+");
  168. if (!file_src)
  169. goto h5fail2;
  170. fclose(file_src);
  171. FILE * file_dst = fopen(hdf5_base_dst, "wb+");
  172. if (!file_dst)
  173. {
  174. goto h5fail2;
  175. }
  176. fclose(file_dst);
  177. /* Initialize StarPU with default configuration */
  178. int ret = starpu_init(NULL);
  179. if (ret == -ENODEV) goto h5enodev;
  180. /* register disks */
  181. int disk_src = starpu_disk_register(ops, (void *) hdf5_base_src, STARPU_DISK_SIZE_MIN);
  182. if (disk_src == -ENOENT) goto h5enoent;
  183. int disk_dst = starpu_disk_register(ops, (void *) hdf5_base_dst, STARPU_DISK_SIZE_MIN);
  184. if (disk_dst == -ENOENT) goto h5enoent;
  185. /* allocate two memory spaces */
  186. starpu_malloc_flags((void **)&A, NX*sizeof(int), STARPU_MALLOC_COUNT);
  187. starpu_malloc_flags((void **)&C, NX*sizeof(int), STARPU_MALLOC_COUNT);
  188. FPRINTF(stderr, "TEST DISK MEMORY \n");
  189. unsigned int j;
  190. /* you register them in a vector */
  191. for(j = 0; j < NX; ++j)
  192. {
  193. A[j] = j;
  194. C[j] = 0;
  195. }
  196. /* Open HDF5 file to store data */
  197. hid_t file = H5Fopen(hdf5_base_src, H5F_ACC_RDWR, H5P_DEFAULT);
  198. if (file < 0)
  199. goto h5fail;
  200. /* store initial data in the file */
  201. hsize_t dims[1] = {NX};
  202. hid_t dataspace = H5Screate_simple(1, dims, NULL);
  203. if (dataspace < 0)
  204. {
  205. H5Fclose(file);
  206. goto h5fail;
  207. }
  208. hid_t dataset = H5Dcreate2(file, path_obj_start, H5T_NATIVE_INT, dataspace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
  209. if (dataset < 0)
  210. {
  211. H5Sclose(dataspace);
  212. H5Fclose(file);
  213. goto h5fail;
  214. }
  215. status = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, A);
  216. /* close the resources before checking the writing */
  217. H5Dclose(dataset);
  218. if (status < 0)
  219. {
  220. H5Fclose(file);
  221. goto h5fail;
  222. }
  223. H5Sclose(dataspace);
  224. H5Fclose(file);
  225. /* Open the file ON the disk */
  226. void * data = starpu_disk_open(disk_src, (void *) path_obj_start, NX*sizeof(int));
  227. starpu_data_handle_t vector_handleA;
  228. starpu_vector_data_register(&vector_handleA, disk_src, (uintptr_t) data, NX, sizeof(int));
  229. /* Move and invalidate copy to an other disk */
  230. starpu_data_acquire_on_node(vector_handleA, disk_dst, STARPU_RW);
  231. starpu_data_release_on_node(vector_handleA, disk_dst);
  232. starpu_data_acquire_on_node(vector_handleA, disk_src, STARPU_RW);
  233. starpu_data_release_on_node(vector_handleA, disk_src);
  234. starpu_data_unregister(vector_handleA);
  235. /* close them in StarPU */
  236. starpu_disk_close(disk_src, data, NX*sizeof(int));
  237. /* check results */
  238. file = H5Fopen(hdf5_base_src, H5F_ACC_RDWR, H5P_DEFAULT);
  239. if (file < 0)
  240. goto h5fail;
  241. dataset = H5Dopen2(file, path_obj_start, H5P_DEFAULT);
  242. if (dataset < 0)
  243. {
  244. H5Fclose(file);
  245. goto h5fail;
  246. }
  247. status = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, C);
  248. /* close the resources before checking the writing */
  249. H5Dclose(dataset);
  250. H5Fclose(file);
  251. if (status < 0)
  252. goto h5fail;
  253. int try = 1;
  254. for (j = 0; j < NX; ++j)
  255. if (A[j] != C[j])
  256. {
  257. FPRINTF(stderr, "Fail A %d != C %d \n", A[j], C[j]);
  258. try = 0;
  259. }
  260. starpu_free_flags(A, NX*sizeof(int), STARPU_MALLOC_COUNT);
  261. starpu_free_flags(C, NX*sizeof(int), STARPU_MALLOC_COUNT);
  262. /* terminate StarPU, no task can be submitted after */
  263. starpu_shutdown();
  264. unlink(hdf5_base_src);
  265. unlink(hdf5_base_dst);
  266. free(hdf5_base_src);
  267. free(hdf5_base_dst);
  268. if(try)
  269. FPRINTF(stderr, "TEST SUCCESS\n");
  270. else
  271. FPRINTF(stderr, "TEST FAIL\n");
  272. return (try ? EXIT_SUCCESS : EXIT_FAILURE);
  273. h5fail:
  274. starpu_free_flags(A, NX*sizeof(int), STARPU_MALLOC_COUNT);
  275. starpu_free_flags(C, NX*sizeof(int), STARPU_MALLOC_COUNT);
  276. h5enoent:
  277. FPRINTF(stderr, "Couldn't write data: ENOENT\n");
  278. starpu_shutdown();
  279. h5enodev:
  280. unlink(hdf5_base_src);
  281. unlink(hdf5_base_dst);
  282. free(hdf5_base_src);
  283. free(hdf5_base_dst);
  284. return STARPU_TEST_SKIPPED;
  285. h5fail2:
  286. free(hdf5_base_src);
  287. free(hdf5_base_dst);
  288. FPRINTF(stderr, "Something goes wrong with HDF5 dataset/dataspace/write \n");
  289. return EXIT_FAILURE;
  290. }
  291. #endif
  292. static int merge_result(int old, int new)
  293. {
  294. if (new == EXIT_FAILURE)
  295. return EXIT_FAILURE;
  296. if (old == 0)
  297. return 0;
  298. return new;
  299. }
  300. int main(void)
  301. {
  302. int ret = 0;
  303. int ret2;
  304. char s[128];
  305. char *ptr;
  306. snprintf(s, sizeof(s), "/tmp/%s-disk-XXXXXX", getenv("USER"));
  307. ptr = _starpu_mkdtemp(s);
  308. if (!ptr)
  309. {
  310. FPRINTF(stderr, "Cannot make directory '%s'\n", s);
  311. return STARPU_TEST_SKIPPED;
  312. }
  313. ret = merge_result(ret, dotest(&starpu_disk_stdio_ops, s));
  314. ret = merge_result(ret, dotest(&starpu_disk_unistd_ops, s));
  315. #ifdef STARPU_LINUX_SYS
  316. if ((NX * sizeof(int)) % getpagesize() == 0)
  317. {
  318. ret = merge_result(ret, dotest(&starpu_disk_unistd_o_direct_ops, s));
  319. }
  320. else
  321. {
  322. ret = merge_result(ret, STARPU_TEST_SKIPPED);
  323. }
  324. #endif
  325. #ifdef STARPU_HAVE_HDF5
  326. ret = merge_result(ret, dotest_hdf5(&starpu_disk_hdf5_ops, s));
  327. #endif
  328. ret2 = rmdir(s);
  329. if (ret2 < 0)
  330. STARPU_CHECK_RETURN_VALUE(-errno, "rmdir '%s'\n", s);
  331. return ret;
  332. }