{"id":6279,"date":"2022-01-08T14:28:50","date_gmt":"2022-01-08T14:28:50","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/dining-philiosophers-problem-iii\/"},"modified":"2023-06-26T09:17:11","modified_gmt":"2023-06-26T09:17:11","slug":"dining-philiosophers-problem-iii","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/dining-philiosophers-problem-iii\/","title":{"rendered":"Dining Philosophers Problem III"},"content":{"rendered":"

This post ends the mini-series about the dining philosophers problem by Andre Adrian<\/strong>. Today, he applies powerful locks and semaphores.<\/p>\n

<\/p>\n

 \"An<\/p>\n

 <\/p>\n

 <\/p>\n

By Benjamin D. Esham \/ Wikimedia Commons, CC BY-SA 3.0, https:\/\/commons.wikimedia.org\/w\/index.php?curid=56559<\/a><\/p>\n

<\/a>Here is a quick reminder about where Andre’s analysis ended last time.<\/p>\n

std::lock_guard<\/code> and Synchronized Output with Resource Hierarchy<\/h2>\n

<\/p>\n

\n
\/\/ dp_10.cpp<\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <chrono><\/span>\r\n#include <mutex><\/span>\r\n\r\nint<\/span> myrand<\/span>(int<\/span> min, int<\/span> max) {\r\n  return<\/span> rand()%<\/span>(max-<\/span>min)+<\/span>min;\r\n}\r\n\r\nstd::<\/span>mutex mo;\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> ga(ma);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> gb(mb);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n  std::<\/span>cout<<<\/span>\"dp_10<\/span>\\n<\/span>\"<\/span>;\r\n  srand(time(nullptr));\r\n\r\n  std::<\/span>mutex m1, m2, m3, m4;\r\n\r\n  std::<\/span>thread<\/span> t1([&<\/span>] {phil(1<\/span>, m1, m2);});\r\n  std::<\/span>thread<\/span> t2([&<\/span>] {phil(2<\/span>, m2, m3);});\r\n  std::<\/span>thread<\/span> t3([&<\/span>] {phil(3<\/span>, m3, m4);});\r\n  std::<\/span>thread<\/span> t4([&<\/span>] {phil(4<\/span>, m1, m4);});\r\n\r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n}\r\n<\/pre>\n<\/div>\n
<\/p>\n
The global mutex mo controls the console output resource. Every cout statement is in its block and the lock_guard(<\/code>) template ensures that console output is not garbled.<\/div>\n
 <\/div>\n
\"dp<\/div>\n<\/div>\n
\n
 <\/div>\n<\/p>\n
A std::unique_lock<\/code> using deferred locking
<\/code><\/h2>\n
 <\/div>\n
C++ offers alternative solutions next to resource hierarchy. We currently have two separate operations to acquire the two resources. If there is only one operation to acquire the two resources, there is no longer the danger of deadlock. The first “all or nothing” solution used unique_lock()<\/code> with defer_lock<\/code>. The actual resource acquire happens in the lock()<\/code> statement. See dp_12.cpp:<\/code><\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
int<\/span> myrand<\/span>(int<\/span> min, int<\/span> max) {\r\n  static<\/span> std::<\/span>mt19937 rnd(std::<\/span>time(nullptr));\r\n  return<\/span> std::<\/span>uniform_int_distribution<><\/span>(min,max)(rnd);\r\n}\r\n\r\nstd::<\/span>mutex mo;\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> ga(ma, std::<\/span>defer_lock);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> gb(mb,std::<\/span>defer_lock);\r\n    std::<\/span>lock(ga, gb);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n  }\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
So far, we have generated random numbers using the rand()<\/code> function.<\/span> This function is not reentrant.<\/span> Not reentrant means not threadable.<\/span> This error is fixed with a modified myrand()<\/code> function.<\/span> The static function object rnd<\/code> is a Mersenne Twister random number generator.<\/span> With static, we avoid a global function object.<\/span> Scaling to a value between min<\/code> and max<\/code> is now done with uniform_int_distribution<><\/code>.<\/span> Using the library is better than writing your code.<\/span> <\/span>Who would have thought simple things like cout output and the random number are so tricky in programs with threads?<\/span><\/span><\/p>\n
\n
<\/code><\/h2>\n
A std::scoped_lock <\/code>with Resource Hierarchy<\/h2>\n
 <\/div>\n
The second “all or nothing” solution is even more straightforward. The C++17 function scoped_lock()<\/code> allows acquiring multiple resources. This powerful function gives us the shortest dining philosophers solution. See dp_13.cpp<\/code>:<\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
void<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n    std::<\/span>scoped_lock sco(ma, mb);\r\n\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma, mb<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n  }\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
There are more solutions. The original Dijkstra solution used one mutex, one semaphore per philosopher, and one state variable per philosopher. [ref 1971; Dijkstra; EWD310 Hierarchical Ordering of Sequential Processes; https:\/\/www.cs.utexas.edu\/users\/EWD\/transcriptions\/EWD03xx\/EWD310.html<\/a>]. Andrew S. Tanenbaum provided a C language solution. [ref 2006; Tanenbaum; Operating Systems. Design and Implementation, 3rd edition; chapter 2.3.1]<\/div>\n
\n
\n
The Original Dining Philosopher’s Problem using Semaphores<\/h2>\n<\/div>\n<\/div>\n
 <\/div>\n
\n
\n
File dp_14.cpp<\/code> is the Tanenbaum solution rewritten in C++20:<\/div>\n<\/div>\n<\/div>\n
 <\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_14.cpp<\/span>\r\n#include <iostream><\/span>\r\n#include <chrono><\/span>\r\n#include <thread><\/span>\r\n#include <mutex><\/span>\r\n#include <semaphore><\/span>\r\n#include <random><\/span>\r\n\r\nint<\/span> myrand<\/span>(int<\/span> min, int<\/span> max) {\r\n  static<\/span> std::<\/span>mt19937 rnd(std::<\/span>time(nullptr));\r\n  return<\/span> std::<\/span>uniform_int_distribution<><\/span>(min,max)(rnd);\r\n}\r\n\r\nenum<\/span> {\r\n  N=<\/span>5<\/span>,                  \/\/ number of philosophers<\/span>\r\n  THINKING=<\/span>0<\/span>,           \/\/ philosopher is thinking<\/span>\r\n  HUNGRY=<\/span>1<\/span>,             \/\/ philosopher is trying to get forks<\/span>\r\n  EATING=<\/span>2<\/span>,             \/\/ philosopher is eating<\/span>\r\n};\r\n\r\n#define LEFT (i+N-1)%N  <\/span>\/\/ number of i's left neighbor<\/span>\r\n#define RIGHT (i+1)%N   <\/span>\/\/ number of i's right neighbor<\/span>\r\n\r\nint<\/span> state[N];           \/\/ array to keep track of everyone's state<\/span>\r\nstd::<\/span>mutex mutex_;      \/\/ mutual exclusion for critical regions<\/span>\r\nstd::<\/span>binary_semaphore s[N]{0<\/span>, 0<\/span>, 0<\/span>, 0<\/span>, 0<\/span>};\r\n                        \/\/ one semaphore per philosopher<\/span>\r\n\r\nvoid<\/span> test<\/span>(int<\/span> i)        \/\/ i: philosopher number, from 0 to N-1<\/span>\r\n{\r\n  if<\/span> (state[i] ==<\/span> HUNGRY\r\n   &&<\/span> state[LEFT] !=<\/span> EATING &&<\/span> state[RIGHT] !=<\/span> EATING) {\r\n    state[i] =<\/span> EATING;\r\n    s[i].release();\r\n  }\r\n}\r\n\r\nvoid<\/span> take_forks<\/span>(int<\/span> i)  \/\/ i: philosopher number, from 0 to N-1<\/span>\r\n{\r\n  mutex_.lock();        \/\/ enter critical region<\/span>\r\n  state[i] =<\/span> HUNGRY;    \/\/ record fact that philosopher i is hungry<\/span>\r\n  test(i);              \/\/ try to acquire 2 forks<\/span>\r\n  mutex_.unlock();      \/\/ exit critical region<\/span>\r\n  s[i].acquire();       \/\/ block if forks were not acquired<\/span>\r\n}\r\n\r\nvoid<\/span> put_forks<\/span>(int<\/span> i)   \/\/ i: philosopher number, from 0 to N-1<\/span>\r\n{\r\n  mutex_.lock();        \/\/ enter critical region<\/span>\r\n  state[i] =<\/span> THINKING;  \/\/ philosopher has finished eating<\/span>\r\n  test(LEFT);           \/\/ see if left neighbor can now eat<\/span>\r\n  test(RIGHT);          \/\/ see if right neighbor can now eat<\/span>\r\n  mutex_.unlock();      \/\/ exit critical region<\/span>\r\n}\r\n\r\nstd::<\/span>mutex mo;\r\n\r\nvoid<\/span> think<\/span>(int<\/span> i) {\r\n  int<\/span> duration =<\/span> myrand(1000<\/span>, 2000<\/span>);\r\n  {\r\n\t\tstd::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n\t\tstd::<\/span>cout<<<\/span>i<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n  }\r\n  std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n}\r\n\r\nvoid<\/span> eat<\/span>(int<\/span> i) {\r\n  int<\/span> duration =<\/span> myrand(1000<\/span>, 2000<\/span>);\r\n  {\r\n\t\tstd::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n\t\tstd::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>i<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n  }\r\n  std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n}\r\n\r\nvoid<\/span> philosopher<\/span>(int<\/span> i) \/\/ i: philosopher number, from 0 to N-1<\/span>\r\n{\r\n  while<\/span> (true<\/span>) {        \/\/ repeat forever<\/span>\r\n    think(i);           \/\/ philosopher is thinking<\/span>\r\n    take_forks(i);      \/\/ acquire two forks or block<\/span>\r\n    eat(i);             \/\/ yum-yum, spaghetti<\/span>\r\n    put_forks(i);       \/\/ put both forks back on table<\/span>\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n  std::<\/span>cout<<<\/span>\"dp_14<\/span>\\n<\/span>\"<\/span>;\r\n\r\n  std::<\/span>thread<\/span> t0([&<\/span>] {philosopher(0<\/span>);});\r\n  std::<\/span>thread<\/span> t1([&<\/span>] {philosopher(1<\/span>);});\r\n  std::<\/span>thread<\/span> t2([&<\/span>] {philosopher(2<\/span>);});\r\n  std::<\/span>thread<\/span> t3([&<\/span>] {philosopher(3<\/span>);});\r\n  std::<\/span>thread<\/span> t4([&<\/span>] {philosopher(4<\/span>);});\r\n  t0.join();\r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
<\/p>\n
By the way, the semaphore is the oldest thread synchronization primitive. Dijkstra defined the P() and V() operation in 1965: “It is the P-operation, which represents the potential delay, viz. when a process initiates a P-operation on a semaphore, that at that moment is = 0, in that case, this P-operation cannot be completed until another process has performed a V-operation on the same semaphore and has given it the value ‘1’.” Today P() is called release()<\/code> and V() is called acquire()<\/code>. [ref 1965; Dijkstra; EWD123 Cooperating sequential processes; https:\/\/www.cs.utexas.edu\/users\/EWD\/transcriptions\/EWD01xx\/EWD123.html<\/a>]<\/div>\n
 <\/div>\n
A C++20 Compatible Semaphore<\/h2>\n
 <\/div>\n
You need  a C++20 compiler like LLVM (clang++) version 13.0.0 or newer to compile dp_14.cpp<\/code>. Or you change the #include <semaphore<\/code>> into #include \"semaphore.h\"<\/code> and provide the following header file. Then a C++11 compiler is sufficient.<\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ semaphore.h<\/span>\r\n#include <mutex><\/span>\r\n#include <condition_variable><\/span>\r\n#include <limits><\/span>\r\n\r\nnamespace<\/span> std {\r\n  template<\/span> <<\/span>std::<\/span>ptrdiff_t<\/span> least_max_value\r\n   =<\/span> std::<\/span>numeric_limits<<\/span>std::<\/span>ptrdiff_t<\/span>>::<\/span>max()><\/span>\r\n  class<\/span> counting_semaphore<\/span> {\r\n  public:<\/span>\r\n    counting_semaphore(std::<\/span>ptrdiff_t<\/span> desired) :<\/span> counter(desired) {}\r\n\r\n    counting_semaphore(const<\/span> counting_semaphore&<\/span>) =<\/span> delete<\/span>;\r\n    counting_semaphore&<\/span> operator<\/span>=<\/span>(const<\/span> counting_semaphore&<\/span>) =<\/span> delete<\/span>;\r\n\r\n    inline<\/span> void<\/span> release<\/span>(ptrdiff_t<\/span> update =<\/span> 1<\/span>) {\r\n      std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> lock(mutex_);\r\n      counter +=<\/span> update;\r\n      cv.notify_one();\r\n    }\r\n\r\n    inline<\/span> void<\/span> acquire<\/span>() {\r\n      std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> lock(mutex_);\r\n      while<\/span> (0<\/span> ==<\/span> counter) cv.wait(lock);\r\n      --<\/span>counter;\r\n    }\r\n\r\n  private:<\/span>\r\n    ptrdiff_t<\/span> counter;\r\n    std::<\/span>mutex mutex_;\r\n    std::<\/span>condition_variable cv;\r\n  };\r\n\r\n  using<\/span> binary_semaphore =<\/span> counting_semaphore<<\/span>1<\/span>><\/span>;\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
The C++ semaphore consists of a counter, a mutex<\/code>, and a condition_variable.<\/code> After 14 program versions, we leave this topic. The programs versions 1 to 6 have problems. I presented them to show bad multi-thread programming. Don’t copy that!<\/div>\n
What’s next?<\/h2>\n
 constexpr<\/code> functions have much in common with templates and become more powerful with C++20. I will write about them in my next post.<\/div>\n
 <\/div>\n
<\/div>\n
 <\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
This post ends the mini-series about the dining philosophers problem by Andre Adrian. Today, he applies powerful locks and semaphores.<\/p>\n","protected":false},"author":21,"featured_media":6268,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[369],"tags":[432,430,431],"class_list":["post-6279","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-application","tag-dining-philosophers","tag-lock","tag-semaphores"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6279","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=6279"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6279\/revisions"}],"predecessor-version":[{"id":6685,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6279\/revisions\/6685"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6268"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6279"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6279"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6279"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}