shadesmar

Shadesmar

Perpustakaan IPC yang menggunakan memori bersama sistem untuk menyampaikan pesan. Mendukung Publish-Subscribe dan RPC.

Membutuhkan: Linux dan x86. Perhatian: Perangkat Lunak Alpha.

Fitur

• Beberapa pelanggan dan penerbit.

• Menggunakan buffer melingkar untuk menyampaikan pesan di antara proses.

• Lebih cepat daripada menggunakan tumpukan jaringan. Throughput tinggi, latensi rendah untuk pesan besar.

• Terdesentralisasi, tanpa kelaparan sumber daya.

• Minimalkan atau mengoptimalkan pergerakan data menggunakan mesin fotokopi khusus.

Penggunaan

Ada satu file header yang dihasilkan dari kode sumber yang dapat ditemukan di sini.

Jika Anda ingin menghasilkan file header tunggal sendiri, klon repo dan jalankan:

 $ cd shadesmar
$ python3 simul/simul.py

Ini akan menghasilkan file dalam include/ .

---

Publikasikan berlangganan

Penerbit:

# include < shadesmar/pubsub/publisher.h >

int main () {
    shm::pubsub::Publisher p ( " topic_name " );
    const uint32_t data_size = 1024 ;
    void *data = malloc (data_size);
    
    for ( int i = 0 ; i < 1000 ; ++i) {
        p. publish (data, data_size);
    }
}

Pelanggan:

# include < shadesmar/pubsub/subscriber.h >

void callback (shm::memory::Memblock *msg) {
  // `msg->ptr` to access `data`
  // `msg->size` to access `data_size`

  // The memory will be free'd at the end of this callback.
  // Copy to another memory location if you want to persist the data.
  // Alternatively, if you want to avoid the copy, you can call
  // `msg->no_delete()` which prevents the memory from being deleted
  // at the end of the callback.
}

int main () {
    shm::pubsub::Subscriber sub ( " topic_name " , callback);

    // Using `spin_once` with a manual loop
    while ( true ) {
        sub. spin_once ();
    }
    // OR
    // Using `spin`
    sub. spin ();
}

---

RPC

Klien:

# include < shadesmar/rpc/client.h >

int main () {
  Client client ( " channel_name " );
  shm::memory::Memblock req, resp;
  // Populate req.
  client. call (req, &resp);
  // Use resp here.

  // resp needs to be explicitly free'd.
  client. free_resp (&resp);
}

Server:

# include < shadesmar/rpc/server.h >

bool callback ( const shm::memory::Memblock &req,
              shm::memory::Memblock *resp) {
  // resp->ptr is a void ptr, resp->size is the size of the buffer.
  // You can allocate memory here, which can be free'd in the clean-up lambda.
  return true ;
}

void clean_up (shm::memory::Memblock *resp) {
  // This function is called *after* the callback is finished. Any memory
  // allocated for the response can be free'd here. A different copy of the
  // buffer is sent to the client, this can be safely cleaned.
}

int main () {
  shm::rpc::Server server ( " channel_name " , callback, clean_up);

  // Using `serve_once` with a manual loop
  while ( true ) {
    server. serve_once ();
  }
  // OR
  // Using `serve`
  server. serve ();
}