Databases
StackOverflow2013
Postsdbo
POD concurrent writing to buffer
 

Note that there are some explanatory texts on larger screens.

plurals
  1. POD concurrent writing to buffer
    primarykey
    data
    text
    <p>Say you have a buffer of size N which must be set to definite values (say to zero, or something else). This value setting in the buffer is divided over M threads, each handling N / M elements of the buffer.</p> <p>The buffer cannot be <code>immutable</code>, since we change the values. Message passing won't work either, since it is forbidden to pass ref or array (= pointer) types. So it must happen through <code>shared</code>? No, since in my case the buffer elements are of type <code>creal</code> and thus arithmetics are not atomic.</p> <p>At the end, the main program must wait until all threads are finished. It is given that each thread only writes to a subset of the array and none of the threads have overlap in the array with another thread or in any way depend on eachother.</p> <p>How would I go about writing to (or modifying) a buffer in a concurrent manner?</p> <p>PS: sometimes I can simply divide the array in M consecutive pieces, but sometimes I go over the array (the array is 1D but represents 2D data) column-by-column. Which makes the individual arrays the threads use be actually interleaved in the mother-array. Argh.</p> <hr> <p>EDIT: I figured out that the type <code>shared(creal)[]</code> would work, since now the elements are shared and not the array itself. You could parallelize interleaved arrays I bet. There is some disadvantage though:</p> <p>The <code>shared</code> storage class is so strict, that the allocation must be supplied with the keyword. Which makes it hardly encapsulated; since the caller must supply the array, it is obligated to pass a <code>shared</code> array and can't just generically pass a regular array and let the processing function worry about parallelism. No, the calling function must worry about parallelism too, so that the processing function receives a shared array and needn't reallocate the array into <code>shared</code> space.</p> <p><strike>There is also a very strange bug, that when I dynamically allocate <code>shared(creal)[]</code> at certain spots, it simply hangs at allocation. Seems very random and can't find the culprit... In the test example this works, but not in my project...</strike> <em>This turned out to be a bug in DMD / OptLink.</em></p> <hr> <p>EDIT2: I never mentioned, but it's for implementing the FFT (Fast Fourier Theorem). So I have no power over selecting precise cache aligned slices. All I know is the elements are of type creal and the number of elements is a power of 2 (per row / column).</p>
    singulars
    1. PO
      singulars
      1. PTAnswer
    1. This table or related slice is empty.
    1. PTQuestion
    1. USTaco de Wolff
    1. USTaco de Wolff
    plurals
    1. This table or related slice is empty.
    1. PL
      singulars
      1. LTLinked
    1. This table or related slice is empty.
    1. PO
      singulars
      1. PTAnswer
    1. VO
      singulars
      1. POD concurrent writing to buffer
      1. This table or related slice is empty.
      1. VTUpMod
    2. VO
      singulars
      1. POD concurrent writing to buffer
      1. This table or related slice is empty.
      1. VTUpMod
    3. VO
      singulars
      1. POD concurrent writing to buffer
      1. This table or related slice is empty.
      1. VTUpMod
    1. COWhat you are trying sounds more like parallelism than concurrency. You may take a look into std.parallelism: http://www.d-programming-language.org/phobos/std_parallelism.html
      singulars
      1. POD concurrent writing to buffer
      1. USMafi
    2. COJust a meta-comment: if read/write on the array is a possible bottleneck, try to size your slices so they align with cache-line boundaries. Otherwise the threads will clobber each other's caches, and you could see a noticeable performance drop.
      singulars
      1. POD concurrent writing to buffer
      1. USgmfawcett
    3. CO@gmfawcett: Or, possibly more simply, just make the work units big enough that the cache lines that are shared between threads are a small fraction of the total cache lines used.
      singulars
      1. POD concurrent writing to buffer
      1. USdsimcha
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload