vector-scal.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132
  1. /*
  2. * StarPU
  3. * Copyright (C) INRIA 2008-2009 (see AUTHORS file)
  4. *
  5. * This program 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. * This program 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. /*
  17. * This example demonstrates how to use StarPU to scale an array by a factor.
  18. * It shows how to manipulate data with StarPU's data management library.
  19. * 1- how to declare a piece of data to StarPU (starpu_register_vector_data)
  20. * 2- how to describe which data are accessed by a task (task->buffers[0])
  21. * 3- how a kernel can manipulate the data (buffers[0].vector.ptr)
  22. */
  23. #include <stdio.h>
  24. #include <stdint.h>
  25. #include <starpu.h>
  26. #define N 2048
  27. /* This kernel takes a buffer and scales it by a constant factor */
  28. static void scal_func(starpu_data_interface_t *buffers, void *arg)
  29. {
  30. unsigned i;
  31. float *factor = arg;
  32. /*
  33. * The "buffers" array matches the task->buffers one: for instance
  34. * task->buffers[0].handle is a handle that corresponds to a data with
  35. * vector "interface". The starpu_data_interface_t is a union type with
  36. * a field for each defined interface. Here, we manipulate the
  37. * buffers[0].vector field: vector.nx gives the number of elements in
  38. * the array, vector.ptr gives the location of the array (that was
  39. * possibly migrated/replicated), and vector.elemsize gives the size of
  40. * each elements.
  41. */
  42. /* length of the vector */
  43. unsigned n = buffers[0].vector.nx;
  44. /* get a pointer to the local copy of the vector : note that we have to
  45. * cast it in (float *) since a vector could contain any type of
  46. * elements so that the .ptr field is actually a uintptr_t */
  47. float *val = (float *)buffers[0].vector.ptr;
  48. /* scale the vector */
  49. for (i = 0; i < n; i++)
  50. val[i] *= *factor;
  51. }
  52. int main(int argc, char **argv)
  53. {
  54. /* We consider a vector of float that is initialized just as any of C
  55. * data */
  56. float tab[N];
  57. unsigned i;
  58. for (i = 0; i < N; i++)
  59. tab[i] = 1.0f;
  60. fprintf(stderr, "BEFORE : First element was %f\n", tab[0]);
  61. /* Initialize StarPU with default configuration */
  62. starpu_init(NULL);
  63. /* Tell StaPU to associate the "tab" vector with the "tab_handle"
  64. * identifier. When a task needs to access a piece of data, it should
  65. * refer to the handle that is associated to it.
  66. * In the case of the "vector" data interface:
  67. * - the first argument of the registration method is a pointer to the
  68. * handle that should describe the data
  69. * - the second argument is the memory node where the data (ie. "tab")
  70. * resides initially: 0 stands for an address in main memory, as
  71. * opposed to an adress on a GPU for instance.
  72. * - the third argument is the adress of the vector in RAM
  73. * - the fourth argument is the number of elements in the vector
  74. * - the fifth argument is the size of each element.
  75. */
  76. starpu_data_handle tab_handle;
  77. starpu_register_vector_data(&tab_handle, 0, (uintptr_t)tab, N, sizeof(float));
  78. float factor = 3.14;
  79. /* create a synchronous task: any call to starpu_submit_task will block
  80. * until it is terminated */
  81. struct starpu_task *task = starpu_task_create();
  82. task->synchronous = 1;
  83. starpu_codelet cl = {
  84. .where = CORE,
  85. /* CPU implementation of the codelet */
  86. .core_func = scal_func,
  87. .nbuffers = 1
  88. };
  89. task->cl = &cl;
  90. /* the codelet manipulates one buffer in RW mode */
  91. task->buffers[0].handle = tab_handle;
  92. task->buffers[0].mode = STARPU_RW;
  93. /* an argument is passed to the codelet, beware that this is a
  94. * READ-ONLY buffer and that the codelet may be given a pointer to a
  95. * COPY of the argument */
  96. task->cl_arg = &factor;
  97. task->cl_arg_size = sizeof(float);
  98. /* execute the task on any eligible computational ressource */
  99. starpu_submit_task(task);
  100. /* StarPU does not need to manipulate the array anymore so we can stop
  101. * monitoring it */
  102. starpu_delete_data(tab_handle);
  103. /* terminate StarPU, no task can be submitted after */
  104. starpu_shutdown();
  105. fprintf(stderr, "AFTER First element is %f\n", tab[0]);
  106. return 0;
  107. }