Why isn't my round robin code working properly?

#include <iostream>
#include <string>
#include <vector>
using namespace std;

// Process
struct Proc
{
  string name;
  size_t arrival; // time of arrival
  size_t exec; // toatal execution time
  bool scheduled; // true if the process is inserted in the execution list
};

// show the Process
ostream & operator << ( ostream & os,  const Proc & proc);

// Execution node
struct Node
{
  const Proc * pproc; // pointer to the actual process
  size_t remain; // remaining execution time
  Node * next;
};

// Execution list
class ExecList
{
  Node* head = nullptr;
  size_t quantum = 3;
  size_t time = 0; // current global execution time

public:
  ~ExecList();
  void insert_nodes( vector <Proc> & vproc); // inserts suitable nodes
  bool execute(); // executes current process ('head')
  void remove();  // removes current process 
  void next(); // moves (head) to next process in the list
  bool is_empty(); // true if there are no more processes in the list
  void dump(); // shows the list (debugging)
};

void ExecList::next()
{
  head = head->next;
}

bool ExecList::is_empty()
{
  return (head == nullptr);
}

void ExecList::dump()
{ 
  Node * cur = head;
  if ( cur == nullptr) return;
  do
  { 
    cout << *(cur->pproc) << "\n";
    cur = cur->next; 
  } while (cur != head);
}

void ExecList::insert_nodes( vector <Proc> & vproc )
{

  // make a sublist with suitable nodes (for later insertion in the execution list) 
  Node * first = nullptr; // sublist first node
  Node * last = nullptr; // sublist last node
  for (auto & proc : vproc)
  {
    // add only not yet scheduled ones
    if ( ! proc.scheduled && proc.arrival <= time )
    {
      Node * cur = new Node();
      cur->pproc = &proc;
      cur->remain = proc.exec;
      proc.scheduled = true; // mark inserted process as 'scheduled'
      cur->next = nullptr;

      if ( first == nullptr )
      {
        first = cur;
        last = cur;
      }
      else
      {
        last->next = cur;
        last = cur;
      }
    }
  }
  // append the sublist at the end of the execution list
  if ( first != nullptr )
  {
    if ( head == nullptr)
    {
      head = first;
      last->next = head;
    }
    else
    {
      // find the last node of the execution list
      Node * exec_last = head;
      while ( exec_last->next != head)
        exec_last = exec_last->next;
      last->next = head;
      exec_last->next = first;
    }
  }
}

ExecList::~ExecList()
{
  // Release (if needed) allocated memory
  Node * cur;

  if ( ! head ) return;

  cur = head;
  do
  {
    Node * next = cur->next;
    delete cur;
    cur = next;
  } while ( cur != head );
}

// executes the current porcess (head). Returns true if the process is finished and should be removed
bool ExecList::execute()
{
  cout << "time " << time << ", executing process " << head->pproc->name << "\n";

  size_t dt = min( quantum, head->remain);

  head->remain -= dt;

  time += dt;

  return (head->remain == 0);
}

// removes the current process (head)
void ExecList::remove()
{
  if ( ! head ) return;

  if ( head->next == head )
  {
    delete head;
    head = nullptr;
    return;
  }

  Node * last = head->next;
  while ( last->next != head )
    last = last->next;

  last->next = head->next;
  delete head;
  head = last->next;
}

ostream & operator << ( ostream & os, const  Proc & proc)
{
  os << "name " << proc.name << ", arrival " << proc.arrival << ", exec " << proc.exec << ", scheduled " << proc.scheduled;
  return os;
}

istream & operator >> (istream & is, Proc & proc)
{
  is >> proc.name >> proc.arrival >> proc.exec;
  proc.scheduled = false;
  return is;
}

int main()
{
  size_t proc_count;
  cout << "how many processes?\n";
  cin >> proc_count;
  vector <Proc> vproc;

  for (size_t n=0; n < proc_count; ++n)
  {
    Proc proc;
    cout << "enter process " << n << " name, arrival time, execution time\n";
    cin >> proc;
    vproc.push_back( proc );
  }

  ExecList el;

  cout << "Execution:\n";

  bool process_finished = false;
  for (;;)
  {
    el.insert_nodes(vproc);
    //el.dump(); // uncomment this line to see the process list at this step
    if ( el.is_empty() ) break;
    if ( process_finished )
    {
      el.remove();
      if ( el.is_empty() ) break;
    }
    else
      el.next();

    process_finished = el.execute();
  }
}