PacketStore.cpp

Go to the documentation of this file.

#include "PacketStore.h"

namespace forest {


PacketStore::PacketStore(int N1, int M1) : N(N1), M(M1) {
                n = m = 0;
                pkt = new Packet[N+1]; pb = new int[N+1];
                buff = new buffer_t[M+1];
                ref = new int[M+1];
                freePkts = new List(N); freeBufs = new List(M);

                int i;
                for (i = 1; i <= N; i++) { freePkts->addLast(i); pb[i] = 0; }
                for (i = 1; i <= M; i++) { freeBufs->addLast(i); ref[i] = 0; }
                pb[0] = ref[0] = 0;
};
                
PacketStore::~PacketStore() {
                delete [] pkt; delete [] pb; delete [] buff; delete [] ref;
                delete freePkts; delete freeBufs;
}

pktx PacketStore::alloc() {
                unique_lock<mutex> lck(mtx);

                if (freePkts->empty() || freeBufs->empty()) {
                                lck.unlock(); return 0;
                }
                n++; m++;
                pktx px = freePkts->get(1); freePkts->removeFirst();
                int b = freeBufs->get(1); freeBufs->removeFirst();
                ref[b] = 1;
                pkt[px].buffer = &buff[b];
                lck.unlock();
                return px;
}

void PacketStore::free(pktx px) {
                unique_lock<mutex> lck(mtx);
                if (px < 1 || px > N || freePkts->member(px)) {
                                lck.unlock(); return;
                }
                int b = pkt[px].buffer - buff;
                freePkts->addFirst(px); n--;
                if ((--ref[b]) == 0) { freeBufs->addFirst(b); m--; }
                lck.unlock();
}

pktx PacketStore::clone(pktx px) {
                unique_lock<mutex> lck(mtx);
                if (freePkts->empty()) {
                                lck.unlock(); return 0;
                }
                n++;
                pktx px1 = freePkts->get(1); freePkts->removeFirst();
                pkt[px1] = pkt[px];
                int b = pkt[px].buffer - buff; ref[b]++;
                lck.unlock();
                return px1;
}

pktx PacketStore::fullCopy(pktx px) {
                unique_lock<mutex> lck(mtx);
                int px1 = alloc();
                if (px1 == 0) {
                                lck.unlock(); return 0;
                }
                lck.unlock();
                Packet& p = getPacket(px); Packet& p1 = getPacket(px1);
                int len = (p.length+3)/4;
                std::copy(p.buffer, p.buffer+len, p1.buffer);
                return px1;
}

} // ends namespace