Under Construction!

defmodule Server do
  @server_name :"server@12.34.56.78"
  def start do
    Node.start(@server_name)
    Node.set_cookie :asdf
    :global.register_name(Node.self(), self())
    IO.puts "Server is at " <> inspect :global.whereis_name(Node.self())
    IO.puts Node.self
    receive do
      {first_client_name, :get_started} -> go([first_client_name])
    end
  end

  defp go(client_names) do
    IO.puts "It's go time!"
    execute_loop(client_names, port_open())
  end
  
  defp port_open do
    Port.open({:spawn, "./simulation"}, [:binary])
  end
  
  defp execute_loop(client_names, sim_port) do
    receive do
      {port, {:data, "Done\n"}} ->
	send(port, {self(), :close})
      {port, {:data, "Starting up\n"}} ->
	IO.puts "Starting up"
	execute_loop(client_names, sim_port)
      {port, {:data, data}} ->
      	#IO.puts "data from port"
	Enum.map(client_names, fn name ->
	#  IO.puts "sending to #{name}"
	  pid = :global.whereis_name(name)
	  if pid != :undefined do
	    send(pid, {pid, {:input, data}})
	  end
	end)
	execute_loop(client_names, sim_port)
      {pid, {:input, input}} ->
      	#IO.puts "received"
	send(sim_port, {self(), {:command, input}})
        execute_loop(client_names, sim_port)
      {client_name, :get_started} ->
	execute_loop(client_names ++ [client_name], sim_port)
      #_ ->
      #	:erlang.hibernate(Server, Server.execute_loop, [client_names, sim_port])
    end
  end
end

Server.start()

The scheme has three subprocesses: (1) a primary bulk diffusion simulation running in a long loop; (2) an auxiliary interface to handle I/O between bulk simulation and the external environment, and; (3) a set of interprocess coordination mechanisms between bulk and interface processes, which exhibit locking behavior that gaurantees ordered and load-balanced execution of the total process.

In main, we spawn a parallel section, fixing the number of threads, and use an OpenMP sections pragma to control the process execution paths of two threads seperately.

Method and structure declarations may be ommitted from exposition.

int main(){
  // enter parallel region, split on two threads
  #pragma omp parallel num_threads(2)
  // note the brackets; good OpenMP practice entails Resource Acquisition is Initialization (RAII) style coding
  {
    // each section will be executed by only one of the two active threads
    #pragma omp sections
    {
      // call the interface and bulk simulation routines one each from the seperate sections.
      // the integers passed (4 and 38 here) will fix the number of additional threads subsequently spawned using nested parallelism
      #pragma omp section
      {
        interface(4);
      } 
      #pragma omp section
      {
	bulk_sim(38);
      }
    }
  }
  return 0;
}

Each routine called in a seperate section will spawn its own parallel region, using nested parallelism. It’s important to know how many cores (or threads, in the case of hyperthreading) are available to provision; if you exceed the provisions, code runtime execution may show massive slowdown, even to speeds and efficiencies far below that of the sequential, non-parallelized version.

void bulk_sim(int num_threads){
  #pragma omp parallel default(shared) num_threads(num_threads)
  {
    // num_cycles is typically a very large number, controlling the number of iterations of your parallel diffusion routine.
    // this is replacing a while loop, which OpenMP doesn't natively support
    // (there is in fact a nice post on parallel-for in OpenMP, but I couldn't get the technique shown there working.
    for(int f = 0; f < num_cycles; f++){
      // primary diffusion code
      // this is a standard five-point stencil finite difference Laplacian
      #pragma omp for collapse(2)
      {
        for(int i = 1; i < side_length - 1; i++){
          for(int j = 1; j < side_length - 1; j++){
            double laplace = ((mesh[i-1][j][0]) + (mesh[i+1][j][0]) + (mesh[i][j-1][0]) + (mesh[i][j+1][0]) - 4.0 * mesh[i][j][0]);
            double height = ((2.0 * mesh[i][j][1]) - mesh[i][j][2] + (pow((waveSpeed), 2.0) * laplace * dampening));
            tempMesh[i][j][0] = height;
          }
        }
      }
      // update mesh separately
      #pragma omp for collapse(2)
      {
        for(int j = 1; j < side_length - 1; j++){
          for(int k = 1; k < side_length - 1; k++){
            mesh[j][k][0] = tempMesh[j][k][0];
            mesh[j][k][2] = mesh[j][k][1];
            mesh[j][k][1] = mesh[j][k][0];
          }
        }
      }
      if(){
        #pragma omp for
        {
          #pragma omp task depend(out: bulk_product)
          {}
        }
      }
      // put jobs that spawn tasks nearer to the top of the stack in which jobs are issued
      // so that idle threads begin executing tasks while subsequent tasks spawn and threads are freed/assigned. 
      #pragma omp single
      {
        // use a depend clause to instantiate dependency between inputs and outputs of tasks concurrently computed by different threads
        #pragma omp task depend(in: bulk_product)
        {}
      }
      #pragma omp single nowait
      {}
      #pragma omp single nowait
      {}
      /* more single nowait jobs here
         large tasks begun early will be finishing */
      #pragma omp single
      {} //the goal being no threads idle at terminus of control flow
    } 
  }
}

At the beginning of each cycle, large jobs issue which occupy all threads; in the middle, threads finish small task chunks at a variety of times; and around the end, numerous small, large, and medium sized jobs are executed. Only at the very end are single-threaded jobs without nowait clauses issued, which instate barriers at which the entire thread team must wait.

By spawning large tasks towards the front of each simulation cycle, we mitigate slowdown due to blocking of thread execution by OpenMP barriers, minimizing the probability that many threads are idle long.

void interface(int num_threads){
{ 
  if(message_received){   
    //(sequentially) lock resources that will mutate depending on information contained in the input message  			 
    omp_set_lock(&input_lock);
    if(){  
    }      
    // unlock the resource(s)
    omp_unset_lock(&input_lock);
  }
    // same for output
  if(message_ready){
    omp_set_lock(output_lock);
    if(){
    }
    omp_unset_lock(&output_lock);
  }
}

On Live Sound

In the last century, a transformation which was applied during the industrial revolution to physical objects, rendering them manufacturable copies, each merely an instance of some mold, has been applied anew to ephemera, things previously appreciable only as felt experiences, reducing¹, for example, the performance of a live orchestra to an infinitely replicable static binary file.

This transformation, like the one before it, appears as the latest iteration in a series of transformations, when viewed through the moral-genealogical lens of a narrative that models the evolution of a culture via the tension between an imagistic, Apollonian force and its sonic, Dionysian counterpart. Though this may sound fanciful, the dualism between stasis and dynamics, image and sound, which the entanglement of these two, inextricably linked forces represents, presents a powerful tool for modeling the zeitgeist of a society, and diagnosing a disharmony in its composition.

When applied to the last few decades, this interpretive lens magnifies a particular, emblematic dissonance between the contemporary cyber and physical worlds; that while the physical world still seems to evolve synchronously, as a single, symphonic gesture, a confluence of local and global orchestration that everywhere satisfies some deep coherence condition, and preserves a property of ‘liveness’, the cyber world feels fragmented, a junkyard of inanimate objects, embedded in disparate environments which do not easily interface or compose, where processes run asynchronously at different rates, unable to communicate and interoperate except via brittle, bespoke bridges that fall into disrepair, having no common, underlying substrate to connect them.

If the industrial revolution divested physical objects of their material provenance, of the natural link between their constituent materials and the environments from whence those materials came, and in so doing, dissolved the bond between craftsmen and their handiwork, then the information revolution has done the same to ephemera, to transient experiences, divesting them of the very meaning of occurring at particular places and times, annihilating their spatiotemporal provenance, retaining only the thinnest and lowest-cost of ad-hoc, asynchronous connectives between isolated, fragmented encodings of experience. The consequence of this has been the dissolution not only of bonds between creators of ephemera, musicians, and their music, but also between ephemera and its beholders, audiences.

Whereas in the physical world, sound is live, synchronous, and reactive, in the cyber world, even virtual environments endowed everywhere with the highest verisimilitude, what is called sound is not really sound at all, or is dead sound.

Consider that in the implementation of a typical virtual space, such as a game world, sounds are files, often preloaded, embedded in a logic that determines when, under what conditions, and with what spectral transformations they are to be triggered for transmission over a network, and then actuated. The logic that determines this behavior of sound files associates, to each conjunction of a point in virtual space and moment in virtual time when and where a listener is present, a file that is either loaded or produced, in real-time or not, using a closed- form, analytic solution. Such a solution is fixed by geometric invariants and simulated material properties of the scene, and in environments where it is demanded that what a listener hears correspond faithfully to what they see, the set of available solutions also constrains the scene itself, since for the vast majority of possible scenes, closed-form analytic solutions for sound wave propagation within them are not yet known.

While the advantage of such an approach is its economy of computation, whereby the evolution of a sonic landscape is computed only when and where it is needed in order to corroborate a visual scene, there is a deep, philosophical disadvantage; the ad hoc algebraicmanipulations which orchestrate the encoding and emission of sounds cause them to be actuated, if at all, only upon egress from the virtual world proper, via individual end-user- interfaces at the boundary of the system, which might transduce them into air. The sound files never exist in, or affect the virtual world.

The dissonance that exists today between contemporary cyber and physical worlds may not be simply the result of error, which arising due to poor approximation of real-world phenomena by yet incomplete models will, as our science improves, eventually vanish, so we inevitably attain a kind of isomorphism between sound in virtual and physical space. Rather, our current approach to the realization of sound in virtual environments may be unable to preserve the properties of sound, which give it its intrinsic semantics. For as long as the imagistic semantics of the virtual world determines its sonic ones, but not vise-versa, it may attain coherence as a kind of game, composed of ad-hoc relations, but it will never attain the immanence of the physical world, orchestrated, as it perhaps wholly is, by compositions of live sound.

C++ library under construction. Code based on the Parshl program ¹.

Example of an artistic² output: https://soundcloud.com/jake-araujo-simon/iris