You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by jp...@apache.org on 2010/05/19 23:06:42 UTC
svn commit: r946395 [4/8] - in /trafficserver/traffic/trunk:
example/app-template/ iocore/aio/ iocore/block-cache/ iocore/cache/
iocore/cluster/ iocore/dns/ iocore/eventsystem/ iocore/hostdb/
iocore/hostdb/include/ iocore/net/ iocore/utils/ libinktomi+...
Modified: trafficserver/traffic/trunk/iocore/net/P_UDPNet.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_UDPNet.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_UDPNet.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_UDPNet.h Wed May 19 21:06:35 2010
@@ -58,8 +58,8 @@ struct UDPNetProcessorInternal : public
EThread *ethread;
UDPNetHandler *udpNetHandler;
#else
- ink_off_t pollCont_offset;
- ink_off_t udpNetHandler_offset;
+ off_t pollCont_offset;
+ off_t udpNetHandler_offset;
#endif
public:
@@ -80,7 +80,7 @@ public:
void BulkIOSend();
// In the absence of bulk-io, we are down sending packet after packet
void SendPackets();
- void SendUDPPacket(UDPPacketInternal * p, ink32 pktLen);
+ void SendUDPPacket(UDPPacketInternal * p, int32 pktLen);
// Interface exported to the outside world
void send(UDPPacket * p);
@@ -105,7 +105,7 @@ public:
#define SLOT_TIME HRTIME_MSECONDS(SLOT_TIME_MSEC)
#define N_SLOTS 2048
-extern inku64 g_udp_bytesPending;
+extern uint64 g_udp_bytesPending;
class PacketQueue
{
@@ -414,14 +414,14 @@ struct InkSinglePipeInfo
double wt;
// all are in bps (bits per sec.) so that we can do ink_atomic_increment
- ink64 bwLimit;
- ink64 bwAlloc;
+ int64 bwLimit;
+ int64 bwAlloc;
// this is in Mbps
double bwUsed;
- ink32 destIP;
- inku32 count;
- inku64 bytesSent;
- inku64 pktsSent;
+ int32 destIP;
+ uint32 count;
+ uint64 bytesSent;
+ uint64 pktsSent;
PacketQueue *queue;
};
Modified: trafficserver/traffic/trunk/iocore/net/P_UDPPacket.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_UDPPacket.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_UDPPacket.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_UDPPacket.h Wed May 19 21:06:35 2010
@@ -53,9 +53,9 @@ public:
SLINK(UDPPacketInternal, alink); // atomic link
// packet scheduling stuff: keep it a doubly linked list
- inku64 pktSendStartTime;
- inku64 pktSendFinishTime;
- inku32 pktLength;
+ uint64 pktSendStartTime;
+ uint64 pktSendFinishTime;
+ uint32 pktLength;
bool isReliabilityPkt;
@@ -67,7 +67,7 @@ public:
// "WMT seq. #", WMT code maintains a mapping betweeen WMT seq. # and TS
// seq. #. If pktTSSeqNum is set to -1, then this value is ignored by the
// UDP code.
- ink64 pktTSSeqNum;
+ int64 pktTSSeqNum;
ink_hrtime delivery_time; // when to deliver packet
ink_hrtime arrival_time; // when packet arrived
@@ -145,7 +145,7 @@ UDPPacket::setReliabilityPkt()
}
TS_INLINE void
-UDPPacket::setPktTSSeq(ink64 seqno)
+UDPPacket::setPktTSSeq(int64 seqno)
{
UDPPacketInternal *p = (UDPPacketInternal *) this;
p->pktTSSeqNum = seqno;
Modified: trafficserver/traffic/trunk/iocore/net/P_UnixNet.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_UnixNet.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_UnixNet.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_UnixNet.h Wed May 19 21:06:35 2010
@@ -162,7 +162,7 @@ struct EventIO
struct UnixNetVConnection;
struct NetHandler;
typedef int (NetHandler::*NetContHandler) (int, void *);
-typedef unsigned int inku32;
+typedef unsigned int uint32;
extern ink_hrtime last_throttle_warning;
extern ink_hrtime last_shedding_warning;
@@ -213,7 +213,7 @@ extern int http_accept_port_number;
#define NET_THROTTLE_DELAY 50 /* mseconds */
#define INK_MIN_PRIORITY 0
-#define PRINT_IP(x) ((inku8*)&(x))[0],((inku8*)&(x))[1], ((inku8*)&(x))[2],((inku8*)&(x))[3]
+#define PRINT_IP(x) ((uint8*)&(x))[0],((uint8*)&(x))[1], ((uint8*)&(x))[2],((uint8*)&(x))[3]
// function prototype needed for SSLUnixNetVConnection
@@ -287,7 +287,7 @@ net_connections_to_throttle(ThrottleType
{
double headroom = t == ACCEPT ? NET_THROTTLE_ACCEPT_HEADROOM : NET_THROTTLE_CONNECT_HEADROOM;
- ink64 sval = 0, cval = 0;
+ int64 sval = 0, cval = 0;
#ifdef HTTP_NET_THROTTLE
NET_READ_DYN_STAT(http_current_client_connections_stat, cval, sval);
Modified: trafficserver/traffic/trunk/iocore/net/P_UnixNetProcessor.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_UnixNetProcessor.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_UnixNetProcessor.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_UnixNetProcessor.h Wed May 19 21:06:35 2010
@@ -81,8 +81,8 @@ public:
AtomicSLL<NetAccept, NetAccept::Link_link> accepts_on_thread;
// offsets for per thread data structures
- ink_off_t netHandler_offset;
- ink_off_t pollCont_offset;
+ off_t netHandler_offset;
+ off_t pollCont_offset;
// we probably wont need these members
int n_netthreads;
Modified: trafficserver/traffic/trunk/iocore/net/P_UnixNetVConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_UnixNetVConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_UnixNetVConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_UnixNetVConnection.h Wed May 19 21:06:35 2010
@@ -86,8 +86,8 @@ class UnixNetVConnection:public NetVConn
{
public:
- virtual VIO *do_io_read(Continuation *c, ink64 nbytes, MIOBuffer *buf);
- virtual VIO *do_io_write(Continuation *c, ink64 nbytes, IOBufferReader *buf, bool owner = false);
+ virtual VIO *do_io_read(Continuation *c, int64 nbytes, MIOBuffer *buf);
+ virtual VIO *do_io_write(Continuation *c, int64 nbytes, IOBufferReader *buf, bool owner = false);
virtual Action *send_OOB(Continuation *cont, char *buf, int len);
virtual void cancel_OOB();
@@ -166,7 +166,7 @@ public:
(void) state;
}
virtual void net_read_io(NetHandler *nh, EThread *lthread);
- virtual ink64 load_buffer_and_write(ink64 towrite, ink64 &wattempted, ink64 &total_wrote, MIOBufferAccessor & buf);
+ virtual int64 load_buffer_and_write(int64 towrite, int64 &wattempted, int64 &total_wrote, MIOBufferAccessor & buf);
void readTempPriority(NetHandler *nh, int priority);
void readDisable(NetHandler *nh);
void readSignalError(NetHandler *nh, int err);
Modified: trafficserver/traffic/trunk/iocore/net/SSLNetVConnection.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/SSLNetVConnection.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/SSLNetVConnection.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/SSLNetVConnection.cc Wed May 19 21:06:35 2010
@@ -282,10 +282,10 @@ SSLNetVConnection::net_read_io(NetHandle
}
-ink64 SSLNetVConnection::load_buffer_and_write(ink64 towrite, ink64 &wattempted, ink64 &total_wrote, MIOBufferAccessor & buf) {
+int64 SSLNetVConnection::load_buffer_and_write(int64 towrite, int64 &wattempted, int64 &total_wrote, MIOBufferAccessor & buf) {
ProxyMutex *mutex = this_ethread()->mutex;
int r = 0;
- ink64 l = 0;
+ int64 l = 0;
int offset = buf.entry->start_offset;
IOBufferBlock *b = buf.entry->block;
@@ -299,7 +299,7 @@ ink64 SSLNetVConnection::load_buffer_and
continue;
}
// check if to amount to write exceeds that in this buffer
- ink64 wavail = towrite - total_wrote;
+ int64 wavail = towrite - total_wrote;
if (l > wavail)
l = wavail;
if (!l)
Modified: trafficserver/traffic/trunk/iocore/net/Socks.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/Socks.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/Socks.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/Socks.cc Wed May 19 21:06:35 2010
@@ -189,7 +189,7 @@ SocksEntry::startEvent(int event, void *
findServer();
- if (server_ip == (inku32) - 1) {
+ if (server_ip == (uint32) - 1) {
Debug("Socks", "Unable to open connection to the SOCKS server");
lerrno = ESOCK_NO_SOCK_SERVER_CONN;
free();
Modified: trafficserver/traffic/trunk/iocore/net/UnixNet.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/UnixNet.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/UnixNet.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/UnixNet.cc Wed May 19 21:06:35 2010
@@ -170,8 +170,8 @@ PollCont::pollEvent(int event, Event *e)
static void
net_signal_hook_callback(EThread *thread) {
#if HAVE_EVENTFD
- inku64 counter;
- NOWARN_UNUSED_RETURN(read(thread->evfd, &counter, sizeof(inku64)));
+ uint64 counter;
+ NOWARN_UNUSED_RETURN(read(thread->evfd, &counter, sizeof(uint64)));
#else
char dummy[1024];
NOWARN_UNUSED_RETURN(read(thread->evpipe[0], &dummy[0], 1024));
@@ -181,8 +181,8 @@ net_signal_hook_callback(EThread *thread
static void
net_signal_hook_function(EThread *thread) {
#if HAVE_EVENTFD
- inku64 counter = 1;
- NOWARN_UNUSED_RETURN(write(thread->evfd, &counter, sizeof(inku64)));
+ uint64 counter = 1;
+ NOWARN_UNUSED_RETURN(write(thread->evfd, &counter, sizeof(uint64)));
#else
char dummy;
NOWARN_UNUSED_RETURN(write(thread->evpipe[1], &dummy, 1));
Modified: trafficserver/traffic/trunk/iocore/net/UnixNetProcessor.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/UnixNetProcessor.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/UnixNetProcessor.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/UnixNetProcessor.cc Wed May 19 21:06:35 2010
@@ -218,7 +218,7 @@ UnixNetProcessor::connect_re_internal(Co
socksEntry->init(cont->mutex, vc, opt->socks_support, opt->socks_version); /*XXXX remove last two args */
socksEntry->action_ = cont;
cont = socksEntry;
- if (socksEntry->server_ip == (inku32) - 1) {
+ if (socksEntry->server_ip == (uint32) - 1) {
socksEntry->lerrno = ESOCK_NO_SOCK_SERVER_CONN;
socksEntry->free();
return ACTION_RESULT_DONE;
Modified: trafficserver/traffic/trunk/iocore/net/UnixNetVConnection.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/UnixNetVConnection.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/UnixNetVConnection.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/UnixNetVConnection.cc Wed May 19 21:06:35 2010
@@ -216,7 +216,7 @@ read_from_net(NetHandler *nh, UnixNetVCo
NetState *s = &vc->read;
ProxyMutex *mutex = thread->mutex;
MIOBufferAccessor & buf = s->vio.buffer;
- ink64 r = 0;
+ int64 r = 0;
MUTEX_TRY_LOCK_FOR(lock, s->vio.mutex, thread, s->vio._cont);
@@ -235,17 +235,17 @@ read_from_net(NetHandler *nh, UnixNetVCo
ink_debug_assert(buf.writer());
// if there is nothing to do, disable connection
- ink64 ntodo = s->vio.ntodo();
+ int64 ntodo = s->vio.ntodo();
if (ntodo <= 0) {
read_disable(nh, vc);
return;
}
- ink64 toread = buf.writer()->write_avail();
+ int64 toread = buf.writer()->write_avail();
if (toread > ntodo)
toread = ntodo;
// read data
- ink64 rattempted = 0, total_read = 0;
+ int64 rattempted = 0, total_read = 0;
int niov = 0;
IOVec tiovec[NET_MAX_IOV];
if (toread) {
@@ -254,10 +254,10 @@ read_from_net(NetHandler *nh, UnixNetVCo
niov = 0;
rattempted = 0;
while (b && niov < NET_MAX_IOV) {
- ink64 a = b->write_avail();
+ int64 a = b->write_avail();
if (a > 0) {
tiovec[niov].iov_base = b->_end;
- ink64 togo = toread - total_read - rattempted;
+ int64 togo = toread - total_read - rattempted;
if (a > togo)
a = togo;
tiovec[niov].iov_len = a;
@@ -416,7 +416,7 @@ write_to_net_io(NetHandler *nh, UnixNetV
return;
}
// If there is nothing to do, disable
- ink64 ntodo = s->vio.ntodo();
+ int64 ntodo = s->vio.ntodo();
if (ntodo <= 0) {
write_disable(nh, vc);
return;
@@ -426,7 +426,7 @@ write_to_net_io(NetHandler *nh, UnixNetV
ink_debug_assert(buf.writer());
// Calculate amount to write
- ink64 towrite = buf.reader()->read_avail();
+ int64 towrite = buf.reader()->read_avail();
if (towrite > ntodo)
towrite = ntodo;
int signalled = 0;
@@ -454,8 +454,8 @@ write_to_net_io(NetHandler *nh, UnixNetV
return;
}
- ink64 total_wrote = 0, wattempted = 0;
- ink64 r = vc->load_buffer_and_write(towrite, wattempted, total_wrote, buf);
+ int64 total_wrote = 0, wattempted = 0;
+ int64 r = vc->load_buffer_and_write(towrite, wattempted, total_wrote, buf);
if (vc->loggingEnabled()) {
char message[256];
snprintf(message, sizeof(message), "rval: %lld towrite: %lld ntodo: %lld total_wrote: %lld",
@@ -522,7 +522,7 @@ write_to_net_io(NetHandler *nh, UnixNetV
VIO *
-UnixNetVConnection::do_io_read(Continuation *c, ink64 nbytes, MIOBuffer *buf)
+UnixNetVConnection::do_io_read(Continuation *c, int64 nbytes, MIOBuffer *buf)
{
addLogMessage("do_io_read");
ink_assert(!closed);
@@ -544,7 +544,7 @@ UnixNetVConnection::do_io_read(Continuat
}
VIO *
-UnixNetVConnection::do_io_write(Continuation *c, ink64 nbytes, IOBufferReader *reader, bool owner)
+UnixNetVConnection::do_io_write(Continuation *c, int64 nbytes, IOBufferReader *reader, bool owner)
{
addLogMessage("do_io_write");
ink_assert(!closed);
@@ -822,18 +822,18 @@ UnixNetVConnection::net_read_io(NetHandl
// I could overwrite it for the SSL implementation
// (SSL read does not support overlapped i/o)
// without duplicating all the code in write_to_net.
-ink64
-UnixNetVConnection::load_buffer_and_write(ink64 towrite, ink64 &wattempted, ink64 &total_wrote, MIOBufferAccessor & buf)
+int64
+UnixNetVConnection::load_buffer_and_write(int64 towrite, int64 &wattempted, int64 &total_wrote, MIOBufferAccessor & buf)
{
- ink64 r = 0;
- ink64 offset = buf.entry->start_offset;
+ int64 r = 0;
+ int64 offset = buf.entry->start_offset;
IOBufferBlock *b = buf.entry->block;
do {
IOVec tiovec[NET_MAX_IOV];
int niov = 0, total_wrote_last = total_wrote;
while (b && niov < NET_MAX_IOV) {
// check if we have done this block
- ink64 l = b->read_avail();
+ int64 l = b->read_avail();
l -= offset;
if (l <= 0) {
offset = -l;
@@ -841,7 +841,7 @@ UnixNetVConnection::load_buffer_and_writ
continue;
}
// check if to amount to write exceeds that in this buffer
- ink64 wavail = towrite - total_wrote;
+ int64 wavail = towrite - total_wrote;
if (l > wavail)
l = wavail;
if (!l)
Modified: trafficserver/traffic/trunk/iocore/net/UnixUDPNet.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/UnixUDPNet.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/UnixUDPNet.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/UnixUDPNet.cc Wed May 19 21:06:35 2010
@@ -50,10 +50,10 @@ EventType ET_UDP;
UDPNetProcessorInternal udpNetInternal;
UDPNetProcessor &udpNet = udpNetInternal;
-inku64 g_udp_bytesPending;
-ink32 g_udp_periodicCleanupSlots;
-ink32 g_udp_periodicFreeCancelledPkts;
-ink32 g_udp_numSendRetries;
+uint64 g_udp_bytesPending;
+int32 g_udp_periodicCleanupSlots;
+int32 g_udp_periodicFreeCancelledPkts;
+int32 g_udp_numSendRetries;
#include "P_LibBulkIO.h"
void *G_bulkIOState = NULL;
@@ -697,7 +697,7 @@ bool
UDPNetProcessor::AllocBandwidth(Continuation * udpConn, double desiredMbps)
{
UDPConnectionInternal *udpIntConn = (UDPConnectionInternal *) udpConn;
- ink64 desiredbps = (ink64) (desiredMbps * 1024.0 * 1024.0);
+ int64 desiredbps = (int64) (desiredMbps * 1024.0 * 1024.0);
if (G_inkPipeInfo.numPipes == 0) {
udpIntConn->flowRateBps = (desiredMbps * 1024.0 * 1024.0) / 8.0;
@@ -724,8 +724,8 @@ bool
UDPNetProcessor::ChangeBandwidth(Continuation * udpConn, double desiredMbps)
{
UDPConnectionInternal *udpIntConn = (UDPConnectionInternal *) udpConn;
- ink64 desiredbps = (ink64) (desiredMbps * 1024.0 * 1024.0);
- ink64 oldbps = (ink64) (udpIntConn->flowRateBps * 8.0);
+ int64 desiredbps = (int64) (desiredMbps * 1024.0 * 1024.0);
+ int64 oldbps = (int64) (udpIntConn->flowRateBps * 8.0);
if (G_inkPipeInfo.numPipes == 0) {
udpIntConn->flowRateBps = (desiredMbps * 1024.0 * 1024.0) / 8.0;
@@ -753,7 +753,7 @@ void
UDPNetProcessor::FreeBandwidth(Continuation * udpConn)
{
UDPConnectionInternal *udpIntConn = (UDPConnectionInternal *) udpConn;
- ink64 bps;
+ int64 bps;
if (G_inkPipeInfo.numPipes == 0)
return;
@@ -817,19 +817,19 @@ void
UDPQueue::service(UDPNetHandler * nh)
{
ink_hrtime now = ink_get_hrtime_internal();
- inku64 timeSpent = 0;
+ uint64 timeSpent = 0;
UDPPacketInternal *p;
ink_hrtime pktSendTime;
double minPktSpacing;
- inku32 pktSize;
- ink32 pktLen;
+ uint32 pktSize;
+ int32 pktLen;
int i;
bool addToGuaranteedQ;
(void) nh;
static ink_hrtime lastPrintTime = ink_get_hrtime_internal();
static ink_hrtime lastSchedTime = ink_get_hrtime_internal();
- static inku32 schedJitter = 0;
- static inku32 numTimesSched = 0;
+ static uint32 schedJitter = 0;
+ static uint32 numTimesSched = 0;
schedJitter += ink_hrtime_to_msec(now - lastSchedTime);
numTimesSched++;
@@ -867,7 +867,7 @@ UDPQueue::service(UDPNetHandler * nh)
// NOTE: this is flow rate in Bytes per sec.; convert to milli-sec.
minPktSpacing = 1000.0 / (p->conn->flowRateBps / p->conn->avgPktSize);
- pktSendTime = p->conn->lastPktStartTime + ink_hrtime_from_msec((inku32) minPktSpacing);
+ pktSendTime = p->conn->lastPktStartTime + ink_hrtime_from_msec((uint32) minPktSpacing);
} else {
minPktSpacing = 0.0;
pktSendTime = p->delivery_time;
@@ -968,19 +968,19 @@ UDPQueue::SendPackets()
// ink_hrtime send_threshold_time = now + HRTIME_MSECONDS(5);
// send packets for SLOT_TIME per attempt
ink_hrtime send_threshold_time = now + SLOT_TIME;
- ink32 bytesThisSlot = INT_MAX, bytesUsed = 0, reliabilityBytes = 0;
- ink32 bytesThisPipe, sentOne, i;
- ink32 pktLen;
+ int32 bytesThisSlot = INT_MAX, bytesUsed = 0, reliabilityBytes = 0;
+ int32 bytesThisPipe, sentOne, i;
+ int32 pktLen;
ink_hrtime timeDelta = 0;
if (now > last_service)
timeDelta = ink_hrtime_to_msec(now - last_service);
if (G_inkPipeInfo.numPipes > 0) {
- bytesThisSlot = (ink32) (((G_inkPipeInfo.reliabilityMbps * 1024.0 * 1024.0) / (8.0 * 1000.0)) * timeDelta);
+ bytesThisSlot = (int32) (((G_inkPipeInfo.reliabilityMbps * 1024.0 * 1024.0) / (8.0 * 1000.0)) * timeDelta);
if (bytesThisSlot == 0) {
// use at most 10% for reliability
- bytesThisSlot = (ink32) (((G_inkPipeInfo.interfaceMbps * 1024.0 * 1024.0) / (8.0 * 1000.0)) * timeDelta * 0.1);
+ bytesThisSlot = (int32) (((G_inkPipeInfo.interfaceMbps * 1024.0 * 1024.0) / (8.0 * 1000.0)) * timeDelta * 0.1);
reliabilityBytes = bytesThisSlot;
}
}
@@ -1007,7 +1007,7 @@ UDPQueue::SendPackets()
if (G_inkPipeInfo.numPipes > 0)
- bytesThisSlot = (ink32) (((G_inkPipeInfo.interfaceMbps * 1024.0 * 1024.0) /
+ bytesThisSlot = (int32) (((G_inkPipeInfo.interfaceMbps * 1024.0 * 1024.0) /
(8.0 * 1000.0)) * timeDelta - reliabilityBytes);
else
bytesThisSlot = INT_MAX;
@@ -1016,7 +1016,7 @@ sendPackets:
sentOne = false;
send_threshold_time = now + SLOT_TIME;
for (i = 0; i < G_inkPipeInfo.numPipes + 1; i++) {
- bytesThisPipe = (ink32) (bytesThisSlot * G_inkPipeInfo.perPipeInfo[i].wt);
+ bytesThisPipe = (int32) (bytesThisSlot * G_inkPipeInfo.perPipeInfo[i].wt);
while ((bytesThisPipe > 0) && (G_inkPipeInfo.perPipeInfo[i].queue->firstPacket(send_threshold_time))) {
p = G_inkPipeInfo.perPipeInfo[i].queue->getFirstPacket();
pktLen = p->getPktLength();
@@ -1057,7 +1057,7 @@ sendPackets:
if ((g_udp_periodicFreeCancelledPkts) &&
(now - lastCleanupTime > ink_hrtime_from_sec(g_udp_periodicFreeCancelledPkts))) {
- inku64 nbytes = g_udp_bytesPending;
+ uint64 nbytes = g_udp_bytesPending;
ink_hrtime startTime = ink_get_hrtime_internal(), endTime;
for (i = 0; i < G_inkPipeInfo.numPipes + 1; i++) {
G_inkPipeInfo.perPipeInfo[i].queue->FreeCancelledPackets(g_udp_periodicCleanupSlots);
@@ -1070,7 +1070,7 @@ sendPackets:
}
void
-UDPQueue::SendUDPPacket(UDPPacketInternal * p, ink32 pktLen)
+UDPQueue::SendUDPPacket(UDPPacketInternal * p, int32 pktLen)
{
IOBufferBlock *b;
struct msghdr msg;
Modified: trafficserver/traffic/trunk/iocore/utils/MTInteractor.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/utils/MTInteractor.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/utils/MTInteractor.cc (original)
+++ trafficserver/traffic/trunk/iocore/utils/MTInteractor.cc Wed May 19 21:06:35 2010
@@ -31,8 +31,8 @@
#define MAYBE_FAIL_TRY_LOCK(_l,_t) \
if (MUTEX_TAKE_TRY_LOCK(_l, _t)) { \
- if ((inku32)_t->generator.random() < \
- (inku32)(UINT_MAX * LOCK_FAIL_RATE)) { \
+ if ((uint32)_t->generator.random() < \
+ (uint32)(UINT_MAX * LOCK_FAIL_RATE)) { \
MUTEX_UNTAKE_LOCK(_l,_t); \
return false; \
} else { \
Modified: trafficserver/traffic/trunk/iocore/utils/Machine.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/utils/Machine.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/utils/Machine.cc (original)
+++ trafficserver/traffic/trunk/iocore/utils/Machine.cc Wed May 19 21:06:35 2010
@@ -80,7 +80,7 @@ ip(aip)
if (r == NULL) {
unsigned char x[4];
memset(x, 0, sizeof(x));
- *(inku32 *) & x = (inku32) ip;
+ *(uint32 *) & x = (uint32) ip;
Debug("machine_debug", "unable to reverse DNS %u.%u.%u.%u: %d", x[0], x[1], x[2], x[3], data.herrno);
} else
hostname = xstrdup(r->h_name);
@@ -93,7 +93,7 @@ ip(aip)
{
unsigned char x[4];
memset(x, 0, sizeof(x));
- *(inku32 *) & x = (inku32) ip;
+ *(uint32 *) & x = (uint32) ip;
const size_t ip_string_size = sizeof(char) * 16;
ip_string = (char *) xmalloc(ip_string_size);
snprintf(ip_string, ip_string_size, "%u.%u.%u.%u", x[0], x[1], x[2], x[3]);
Modified: trafficserver/traffic/trunk/libinktomi++/Allocator.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/Allocator.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/Allocator.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/Allocator.h Wed May 19 21:06:35 2010
@@ -152,7 +152,7 @@ public:
struct _proto
{
C typeObject;
- ink64 space_holder;
+ int64 space_holder;
} proto;
};
@@ -267,8 +267,8 @@ template<class C> inline C * ClassAlloca
void *ptr = ink_freelist_new(&this->fl);
#endif
if (sizeof(C) < 512) {
- for (unsigned int i = 0; i < RND16(sizeof(C)) / sizeof(ink64); i++)
- ((ink64 *) ptr)[i] = ((ink64 *) &this->proto.typeObject)[i];
+ for (unsigned int i = 0; i < RND16(sizeof(C)) / sizeof(int64); i++)
+ ((int64 *) ptr)[i] = ((int64 *) &this->proto.typeObject)[i];
} else
memcpy(ptr, &this->proto.typeObject, sizeof(C));
return (C *) ptr;
@@ -283,8 +283,8 @@ template<class C> inline C * SparceClass
#endif
if (!instantiate) {
if (sizeof(C) < 512) {
- for (unsigned int i = 0; i < RND16(sizeof(C)) / sizeof(ink64); i++)
- ((ink64 *) ptr)[i] = ((ink64 *) &this->proto.typeObject)[i];
+ for (unsigned int i = 0; i < RND16(sizeof(C)) / sizeof(int64); i++)
+ ((int64 *) ptr)[i] = ((int64 *) &this->proto.typeObject)[i];
} else
memcpy(ptr, &this->proto.typeObject, sizeof(C));
} else
Modified: trafficserver/traffic/trunk/libinktomi++/Compatability.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/Compatability.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/Compatability.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/Compatability.h Wed May 19 21:06:35 2010
@@ -27,7 +27,6 @@
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
-#include <stdint.h>
#include <stdio.h>
#include <strings.h>
@@ -72,30 +71,6 @@ typedef uint32_t in_addr_t;
#define NEED_HRTIME
-#define ink_pread pread
-#define ink_pwrite pwrite
-#define ink_open open
-#define ink_close close
-#define ink_lseek lseek
-#define ink_write write
-#define ink_pwrite pwrite
-#define ink_read read
-#define ink_pread pread
-#define ink_writev writev
-#define ink_readv readv
-#define ink_fsync fsync
-#define ink_ftruncate ftruncate
-
-#if (HOST_OS == freebsd) || (HOST_OS == darwin)
-#define ink_ftruncate64(_fd,_s) ftruncate(_fd, (off_t)(_s))
-#else
-#define ink_ftruncate64 ftruncate64
-#endif
-
-#define ink_fstat fstat
-#define ink_mmap mmap
-#define ink_sleep sleep
-
#include "Resource.h"
#endif
Modified: trafficserver/traffic/trunk/libinktomi++/DAllocator.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/DAllocator.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/DAllocator.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/DAllocator.cc Wed May 19 21:06:35 2010
@@ -38,7 +38,7 @@
#define DALLOC_DESCRIPTOR_MAGIC 0x343bbbff
#define DALLOC_RED_ZONE_BYTES 16
-#define DALLOC_MAKE_RED_ZONE(x) (inku32) x | 0x189dda3f
+#define DALLOC_MAKE_RED_ZONE(x) (uint32) x | 0x189dda3f
void
write_red_zone(void *el, int el_size)
@@ -48,21 +48,21 @@ write_red_zone(void *el, int el_size)
return;
}
- inku32 red = DALLOC_MAKE_RED_ZONE(el);
+ uint32 red = DALLOC_MAKE_RED_ZONE(el);
int i;
- inku32 *write_ptr = (inku32 *) el;
+ uint32 *write_ptr = (uint32 *) el;
// Redzone the front the object
- for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(inku32); i++) {
+ for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(uint32); i++) {
*write_ptr = red;
write_ptr++;
}
// Redzone the back of the object
- write_ptr = (inku32 *) (((char *) el) + el_size - DALLOC_RED_ZONE_BYTES);
- for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(inku32); i++) {
+ write_ptr = (uint32 *) (((char *) el) + el_size - DALLOC_RED_ZONE_BYTES);
+ for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(uint32); i++) {
*write_ptr = red;
write_ptr++;
}
@@ -76,13 +76,13 @@ check_red_zone(void *el, int el_size)
return 1;
}
- inku32 red = DALLOC_MAKE_RED_ZONE(el);
+ uint32 red = DALLOC_MAKE_RED_ZONE(el);
int i;
- inku32 *read_ptr = (inku32 *) el;
+ uint32 *read_ptr = (uint32 *) el;
// Check the front the object
- for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(inku32); i++) {
+ for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(uint32); i++) {
if (*read_ptr != red) {
return 0;
}
@@ -90,8 +90,8 @@ check_red_zone(void *el, int el_size)
}
// Check the back of the object
- read_ptr = (inku32 *) (((char *) el) + el_size - DALLOC_RED_ZONE_BYTES);
- for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(inku32); i++) {
+ read_ptr = (uint32 *) (((char *) el) + el_size - DALLOC_RED_ZONE_BYTES);
+ for (i = 0; i < DALLOC_RED_ZONE_BYTES / sizeof(uint32); i++) {
if (*read_ptr != red) {
return 0;
}
Modified: trafficserver/traffic/trunk/libinktomi++/INK_MD5.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/INK_MD5.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/INK_MD5.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/INK_MD5.h Wed May 19 21:06:35 2010
@@ -33,16 +33,16 @@
struct INK_MD5
{
- inku64 b[2];
+ uint64 b[2];
const INK_MD5 & operator =(const INK_MD5 & md5)
{
b[0] = md5.b[0];
b[1] = md5.b[1];
return md5;
}
- inku32 word(int i)
+ uint32 word(int i)
{
- inku32 *p = (inku32 *) & b[0];
+ uint32 *p = (uint32 *) & b[0];
return p[i];
}
unsigned char byte(int i)
@@ -112,7 +112,7 @@ struct INK_MD5
{
loadFromBuffer(p);
}
- void set(inku64 a1, inku64 a2)
+ void set(uint64 a1, uint64 a2)
{
b[0] = a1;
b[1] = a2;
@@ -131,12 +131,12 @@ struct INK_MD5
return buf;
}
- inku64 fold()
+ uint64 fold()
{
return (b[0] ^ b[1]);
}
- inku64 operator[] (int i)
+ uint64 operator[] (int i)
{
return b[i];
}
@@ -148,7 +148,7 @@ struct INK_MD5
b[0] = 0;
b[1] = 0;
}
- INK_MD5(inku64 a1, inku64 a2) {
+ INK_MD5(uint64 a1, uint64 a2) {
b[0] = a1;
b[1] = a2;
}
Modified: trafficserver/traffic/trunk/libinktomi++/List.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/List.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/List.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/List.h Wed May 19 21:06:35 2010
@@ -374,7 +374,7 @@ template<class C, class L = typename C::
#define ASLLM(_c, _m, _ml, _l) AtomicSLL<_c, _c::Link##_##_ml##_##_l>
template<class C, class L> inline AtomicSLL<C,L>::AtomicSLL() {
- ink_atomiclist_init(&al, "AtomicSLL", (inku32)(uintptr_t)&L::next_link((C*)0));
+ ink_atomiclist_init(&al, "AtomicSLL", (uint32)(uintptr_t)&L::next_link((C*)0));
}
#endif /*_List_h_*/
Modified: trafficserver/traffic/trunk/libinktomi++/MMH.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/MMH.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/MMH.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/MMH.cc Wed May 19 21:06:35 2010
@@ -32,7 +32,7 @@
#define MMH_X_SIZE 512
/* BUG: INKqa11504: need it be to 64 bits...otherwise it overflows */
-static inku64 MMH_x[MMH_X_SIZE + 8] = {
+static uint64 MMH_x[MMH_X_SIZE + 8] = {
0x3ee18b32, 0x746d0d6b, 0x591be6a3, 0x760bd17f,
0x363c765d, 0x4bf3d5c5, 0x10f0510a, 0x39a84605,
0x2282b48f, 0x6903652e, 0x1b491170, 0x1ab8407a,
@@ -195,10 +195,10 @@ ink_code_incr_MMH_init(MMH_CTX * ctx)
{
ctx->buffer_size = 0;
ctx->blocks = 0;
- ctx->state[0] = ((inku64) MMH_x[MMH_X_SIZE + 0] << 32) + MMH_x[MMH_X_SIZE + 1];
- ctx->state[1] = ((inku64) MMH_x[MMH_X_SIZE + 2] << 32) + MMH_x[MMH_X_SIZE + 3];
- ctx->state[2] = ((inku64) MMH_x[MMH_X_SIZE + 4] << 32) + MMH_x[MMH_X_SIZE + 5];
- ctx->state[3] = ((inku64) MMH_x[MMH_X_SIZE + 6] << 32) + MMH_x[MMH_X_SIZE + 7];
+ ctx->state[0] = ((uint64) MMH_x[MMH_X_SIZE + 0] << 32) + MMH_x[MMH_X_SIZE + 1];
+ ctx->state[1] = ((uint64) MMH_x[MMH_X_SIZE + 2] << 32) + MMH_x[MMH_X_SIZE + 3];
+ ctx->state[2] = ((uint64) MMH_x[MMH_X_SIZE + 4] << 32) + MMH_x[MMH_X_SIZE + 5];
+ ctx->state[3] = ((uint64) MMH_x[MMH_X_SIZE + 6] << 32) + MMH_x[MMH_X_SIZE + 7];
return 0;
}
@@ -215,7 +215,7 @@ ink_code_MMH(unsigned char *input, int l
static inline void
MMH_update(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) ab;
+ uint32 *b = (uint32 *) ab;
ctx->state[0] += b[0] * MMH_x[(ctx->blocks + 0) % MMH_X_SIZE];
ctx->state[1] += b[1] * MMH_x[(ctx->blocks + 1) % MMH_X_SIZE];
ctx->state[2] += b[2] * MMH_x[(ctx->blocks + 2) % MMH_X_SIZE];
@@ -226,8 +226,8 @@ MMH_update(MMH_CTX * ctx, unsigned char
static inline void
MMH_updateb1(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) (ab - 1);
- inku32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
+ uint32 *b = (uint32 *) (ab - 1);
+ uint32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
b0 = (b0 << 8) + (b1 >> 24);
b1 = (b1 << 8) + (b2 >> 24);
b2 = (b2 << 8) + (b3 >> 24);
@@ -242,8 +242,8 @@ MMH_updateb1(MMH_CTX * ctx, unsigned cha
static inline void
MMH_updateb2(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) (ab - 2);
- inku32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
+ uint32 *b = (uint32 *) (ab - 2);
+ uint32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
b0 = (b0 << 16) + (b1 >> 16);
b1 = (b1 << 16) + (b2 >> 16);
b2 = (b2 << 16) + (b3 >> 16);
@@ -258,8 +258,8 @@ MMH_updateb2(MMH_CTX * ctx, unsigned cha
static inline void
MMH_updateb3(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) (ab - 3);
- inku32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
+ uint32 *b = (uint32 *) (ab - 3);
+ uint32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
b0 = (b0 << 24) + (b1 >> 8);
b1 = (b1 << 24) + (b2 >> 8);
b2 = (b2 << 24) + (b3 >> 8);
@@ -274,8 +274,8 @@ MMH_updateb3(MMH_CTX * ctx, unsigned cha
static inline void
MMH_updatel1(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) (ab - 1);
- inku32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
+ uint32 *b = (uint32 *) (ab - 1);
+ uint32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
b0 = (b0 >> 8) + (b1 << 24);
b1 = (b1 >> 8) + (b2 << 24);
b2 = (b2 >> 8) + (b3 << 24);
@@ -290,8 +290,8 @@ MMH_updatel1(MMH_CTX * ctx, unsigned cha
static inline void
MMH_updatel2(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) (ab - 2);
- inku32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
+ uint32 *b = (uint32 *) (ab - 2);
+ uint32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
b0 = (b0 >> 16) + (b1 << 16);
b1 = (b1 >> 16) + (b2 << 16);
b2 = (b2 >> 16) + (b3 << 16);
@@ -306,8 +306,8 @@ MMH_updatel2(MMH_CTX * ctx, unsigned cha
static inline void
MMH_updatel3(MMH_CTX * ctx, unsigned char *ab)
{
- inku32 *b = (inku32 *) (ab - 3);
- inku32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
+ uint32 *b = (uint32 *) (ab - 3);
+ uint32 b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4];
b0 = (b0 >> 24) + (b1 << 8);
b1 = (b1 >> 24) + (b2 << 8);
b2 = (b2 >> 24) + (b3 << 8);
@@ -412,7 +412,7 @@ _memset(unsigned char *b, int c, int len
for (i = 0; i < o; i++)
b[i] = 0;
for (i = 0; i < (len - o) / 4; i++)
- ((inku32 *) (b + o))[i] = 0;
+ ((uint32 *) (b + o))[i] = 0;
}
#endif
@@ -432,12 +432,12 @@ ink_code_incr_MMH_final(char *presult, M
pbuffer[1] = pbuffer[2] = pbuffer[3] = pbuffer[0] = len;
MMH_update(ctx, ctx->buffer);
// final phase
- inku32 *b = (inku32 *) presult;
- inku64 d = (((inku64) 1) << 32) + 15;
- inku32 b0 = inku32(ctx->state[0] % d);
- inku32 b1 = inku32(ctx->state[1] % d);
- inku32 b2 = inku32(ctx->state[2] % d);
- inku32 b3 = inku32(ctx->state[3] % d);
+ uint32 *b = (uint32 *) presult;
+ uint64 d = (((uint64) 1) << 32) + 15;
+ uint32 b0 = uint32(ctx->state[0] % d);
+ uint32 b1 = uint32(ctx->state[1] % d);
+ uint32 b2 = uint32(ctx->state[2] % d);
+ uint32 b3 = uint32(ctx->state[3] % d);
// scramble the bits, losslessly (reversibly)
b[0] = b0;
b[1] = b1 ^ (b0 >> 24) ^ (b0 << 8);
@@ -466,7 +466,7 @@ ink_code_incr_MMH_final(char *presult, M
#define TEST_COLLISIONS 10000000
static int
-xxcompar(inku32 ** x, inku32 ** y)
+xxcompar(uint32 ** x, uint32 ** y)
{
for (int i = 0; i < 4; i++) {
if (x[i] > y[i])
@@ -477,7 +477,7 @@ xxcompar(inku32 ** x, inku32 ** y)
return 0;
}
-typedef inku32 i4_t[4];
+typedef uint32 i4_t[4];
i4_t *xxh;
double *xf;
@@ -486,10 +486,10 @@ main()
union
{
unsigned char hash[16];
- inku32 h[4];
+ uint32 h[4];
} h;
- xxh = (i4_t *) malloc(4 * sizeof(inku32) * TEST_COLLISIONS);
+ xxh = (i4_t *) malloc(4 * sizeof(uint32) * TEST_COLLISIONS);
xf = (double *) malloc(sizeof(double) * TEST_COLLISIONS);
printf("test collisions\n");
Modified: trafficserver/traffic/trunk/libinktomi++/MMH.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/MMH.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/MMH.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/MMH.h Wed May 19 21:06:35 2010
@@ -32,7 +32,7 @@
struct MMH_CTX
{
- inku64 state[4];
+ uint64 state[4];
unsigned char buffer[32];
int buffer_size;
int blocks;
@@ -54,7 +54,7 @@ int inkcoreapi ink_code_MMH(unsigned cha
*/
struct MMH
{
- inku64 b[2];
+ uint64 b[2];
MMH & operator =(MMH & MMH)
{
b[0] = MMH.b[0];
@@ -112,11 +112,11 @@ struct MMH
{
return (ink_code_md5_stringify_fast(hex_MMH, str()));
}
- inku64 fold() const
+ uint64 fold() const
{
return (b[0] ^ b[1]);
}
- inku64 operator[] (int i) const
+ uint64 operator[] (int i) const
{
return b[i];
}
Modified: trafficserver/traffic/trunk/libinktomi++/Makefile.am
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/Makefile.am?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/Makefile.am (original)
+++ trafficserver/traffic/trunk/libinktomi++/Makefile.am Wed May 19 21:06:35 2010
@@ -82,7 +82,7 @@ libinktomi___a_SOURCES = \
ink_port.h \
ink_queue.cc \
ink_queue.h \
- ink_queue_utils.c \
+ ink_queue_utils.cc \
ink_rand.cc \
ink_rand.h \
ink_res_init.cc \
Modified: trafficserver/traffic/trunk/libinktomi++/MatcherUtils.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/MatcherUtils.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/MatcherUtils.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/MatcherUtils.cc Wed May 19 21:06:35 2010
@@ -54,20 +54,20 @@ readIntoBuffer(char *file_path, const ch
}
// Open the file for Blocking IO. We will be reading this
// at start up and infrequently afterward
- if ((fd = ink_open(file_path, O_RDONLY | _O_ATTRIB_NORMAL)) < 0) {
+ if ((fd = open(file_path, O_RDONLY | _O_ATTRIB_NORMAL)) < 0) {
Error("%s Can not open %s file : %s", module_name, file_path, strerror(errno));
return NULL;
}
- if (ink_fstat(fd, &file_info) < 0) {
+ if (fstat(fd, &file_info) < 0) {
Error("%s Can not stat %s file : %s", module_name, file_path, strerror(errno));
- ink_close(fd);
+ close(fd);
return NULL;
}
if (file_info.st_size < 0) {
Error("%s Can not get correct file size for %s file : %lld", module_name, file_path, (long long) file_info.st_size);
- ink_close(fd);
+ close(fd);
return NULL;
}
// Allocate a buffer large enough to hold the entire file
@@ -77,7 +77,7 @@ readIntoBuffer(char *file_path, const ch
// Null terminate the buffer so that string operations will work
file_buf[file_info.st_size] = '\0';
- read_size = (file_info.st_size > 0) ? ink_read(fd, file_buf, file_info.st_size) : 0;
+ read_size = (file_info.st_size > 0) ? read(fd, file_buf, file_info.st_size) : 0;
// Check to make sure that we got the whole file
if (read_size < 0) {
@@ -99,7 +99,7 @@ readIntoBuffer(char *file_path, const ch
*read_size_ptr = read_size;
}
- ink_close(fd);
+ close(fd);
return file_buf;
}
Modified: trafficserver/traffic/trunk/libinktomi++/ParseRules.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ParseRules.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ParseRules.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ParseRules.cc Wed May 19 21:06:35 2010
@@ -41,10 +41,10 @@ const char parseRulesCTypeToLower[256] =
};
unsigned char *
-ParseRules::scan_while(unsigned char *ptr, unsigned int n, inku32 bitmask)
+ParseRules::scan_while(unsigned char *ptr, unsigned int n, uint32 bitmask)
{
unsigned int i;
- inku32 *wptr;
+ uint32 *wptr;
unsigned char *align_ptr;
uintptr_t f_bytes, b_bytes, words, align_off;
@@ -60,7 +60,7 @@ ParseRules::scan_while(unsigned char *pt
if (!is_type(ptr[i], bitmask))
return (&ptr[i]);
} else {
- wptr = ((inku32 *) align_ptr) + (align_off ? 1 : 0);
+ wptr = ((uint32 *) align_ptr) + (align_off ? 1 : 0);
switch (align_off) {
case 1:
if (!is_type(align_ptr[1], bitmask))
@@ -79,8 +79,8 @@ ParseRules::scan_while(unsigned char *pt
b_bytes = n - ((words << 2) + f_bytes);
for (i = 0; i < words; i++) {
- inku32 word = wptr[i];
- inku32 result = (is_type(((word >> 0) & 0xFF), bitmask) &
+ uint32 word = wptr[i];
+ uint32 result = (is_type(((word >> 0) & 0xFF), bitmask) &
is_type(((word >> 8) & 0xFF), bitmask) &
is_type(((word >> 16) & 0xFF), bitmask) & is_type(((word >> 24) & 0xFF), bitmask));
if (result == 0) {
@@ -151,9 +151,9 @@ ParseRules::ink_tolower_buffer(char *ptr
break;
}
- inku32 *wptr = (inku32 *) ptr;
+ uint32 *wptr = (uint32 *) ptr;
for (i = 0; i < words; i++) {
- inku32 word = *wptr;
+ uint32 word = *wptr;
((unsigned char *) &word)[0] = ParseRules::ink_tolower(((unsigned char *) &word)[0]);
((unsigned char *) &word)[1] = ParseRules::ink_tolower(((unsigned char *) &word)[1]);
((unsigned char *) &word)[2] = ParseRules::ink_tolower(((unsigned char *) &word)[2]);
Modified: trafficserver/traffic/trunk/libinktomi++/ParseRules.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ParseRules.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ParseRules.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ParseRules.h Wed May 19 21:06:35 2010
@@ -96,7 +96,7 @@ public:
// character tests //
/////////////////////
- static CTypeResult is_type(char c, inku32 bit);
+ static CTypeResult is_type(char c, uint32 bit);
static CTypeResult is_char(char c); // ASCII 0-127
static CTypeResult is_upalpha(char c); // A-Z
@@ -162,7 +162,7 @@ public:
static const char *memchr(const char *s, char c, int max_length);
static const char *strchr(const char *s, char c);
- static unsigned char *scan_while(unsigned char *ptr, unsigned int n, inku32 bitmask);
+ static unsigned char *scan_while(unsigned char *ptr, unsigned int n, uint32 bitmask);
private:
ParseRules(const ParseRules &);
@@ -174,7 +174,7 @@ private:
* * * * * * * * * * * * * * * * * * * * * * * * * * * */
inline CTypeResult
-ParseRules::is_type(char c, inku32 bitmask)
+ParseRules::is_type(char c, uint32 bitmask)
{
return (parseRulesCType[(unsigned char) c] & bitmask);
}
@@ -490,7 +490,7 @@ ParseRules::is_pchar(const char *seq)
{
#ifndef COMPILE_PARSE_RULES
if (*seq != '%')
- return (parseRulesCType[(inku8)*seq] & is_pchar_BIT);
+ return (parseRulesCType[(uint8)*seq] & is_pchar_BIT);
else
return is_hex(seq[1]) && is_hex(seq[2]);
#else
@@ -903,10 +903,10 @@ ink_atoui(const char *str)
}
-static inline ink64
+static inline int64
ink_atoll(const char *str)
{
- ink64 num = 0;
+ int64 num = 0;
int negative = 0;
while (*str && ParseRules::is_wslfcr(*str))
Modified: trafficserver/traffic/trunk/libinktomi++/Regex.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/Regex.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/Regex.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/Regex.cc Wed May 19 21:06:35 2010
@@ -1688,8 +1688,8 @@ re_build(REState ** states,
delete[]counts;
}
-static const ink32 negative_one = -1;
-static const ink32 zero = 0;
+static const int32 negative_one = -1;
+static const int32 zero = 0;
DFA::DFA()
:basetbl(&negative_one), accepttbl(&negative_one), nexttbl(&zero), checktbl(&negative_one)
@@ -1755,7 +1755,7 @@ DFA::compile(const char **patterns, int
int
DFA::compile(const char *filename, const char **patterns, int npatterns, REFlags flags)
{
- static ink32 magic = 0x01020304;
+ static int32 magic = 0x01020304;
DynArray<int>*tables[4];
int length;
INK_DIGEST_CTX md5_context;
@@ -1777,44 +1777,44 @@ DFA::compile(const char *filename, const
ink_code_incr_md5_final((char *) &md5, &md5_context);
#ifndef TS_MICRO
- fd = ink_open(filename, O_RDONLY | _O_ATTRIB_NORMAL);
+ fd = open(filename, O_RDONLY | _O_ATTRIB_NORMAL);
#else
fd = -1;
#endif
if (fd > 0) {
INK_MD5 old_md5;
- ink32 old_magic;
+ int32 old_magic;
tables[0] = &basetbl;
tables[1] = &accepttbl;
tables[2] = &nexttbl;
tables[3] = &checktbl;
- err = ink_read(fd, &old_magic, sizeof(old_magic));
+ err = read(fd, &old_magic, sizeof(old_magic));
if ((err != sizeof(old_magic)) || (old_magic != magic)) {
goto fail;
}
- err = ink_read(fd, &old_md5, sizeof(old_md5));
+ err = read(fd, &old_md5, sizeof(old_md5));
if ((err != sizeof(old_md5)) || (!(old_md5 == md5))) {
goto fail;
}
for (i = 0; i < 4; i++) {
- err = ink_read(fd, &length, sizeof(length));
+ err = read(fd, &length, sizeof(length));
if (err != sizeof(length)) {
goto fail;
}
tables[i]->set_length(length);
(*tables[i]) (tables[i]->length() - 1) = tables[i]->defvalue();
- err = ink_read(fd, (ink32 *) (*tables[i]), sizeof(ink32) * (tables[i]->length()));
- if (err != (int) (sizeof(ink32) * (tables[i]->length()))) {
+ err = read(fd, (int32 *) (*tables[i]), sizeof(int32) * (tables[i]->length()));
+ if (err != (int) (sizeof(int32) * (tables[i]->length()))) {
goto fail;
}
}
- ink_close(fd);
+ close(fd);
return 0;
fail:
@@ -1822,7 +1822,7 @@ DFA::compile(const char *filename, const
tables[1]->clear();
tables[2]->clear();
tables[3]->clear();
- ink_close(fd);
+ close(fd);
}
err = compile(patterns, npatterns, flags);
@@ -1830,17 +1830,17 @@ DFA::compile(const char *filename, const
return err;
}
#ifndef TS_MICRO
- fd = ink_open(filename, O_CREAT | O_TRUNC | O_WRONLY | _O_ATTRIB_NORMAL, 0755);
+ fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | _O_ATTRIB_NORMAL, 0755);
if (fd < 0) {
return 0;
}
- err = ink_write(fd, &magic, sizeof(magic));
+ err = write(fd, &magic, sizeof(magic));
if (err != sizeof(magic)) {
goto done;
}
- err = ink_write(fd, &md5, sizeof(md5));
+ err = write(fd, &md5, sizeof(md5));
if (err != sizeof(md5)) {
goto done;
}
@@ -1852,19 +1852,19 @@ DFA::compile(const char *filename, const
for (i = 0; i < 4; i++) {
length = tables[i]->length();
- err = ink_write(fd, &length, sizeof(length));
+ err = write(fd, &length, sizeof(length));
if (err != sizeof(length)) {
goto done;
}
- err = ink_write(fd, (ink32 *) (*tables[i]), sizeof(ink32) * (tables[i]->length()));
- if (err != (int) (sizeof(ink32) * (tables[i]->length()))) {
+ err = write(fd, (int32 *) (*tables[i]), sizeof(int32) * (tables[i]->length()));
+ if (err != (int) (sizeof(int32) * (tables[i]->length()))) {
goto done;
}
}
done:
- ink_close(fd);
+ close(fd);
#endif // TS_MICRO
return 0;
}
Modified: trafficserver/traffic/trunk/libinktomi++/Regex.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/Regex.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/Regex.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/Regex.h Wed May 19 21:06:35 2010
@@ -88,10 +88,10 @@ public:
int size();
private:
- DynArray<ink32> basetbl;
- DynArray<ink32> accepttbl;
- DynArray<ink32> nexttbl;
- DynArray<ink32> checktbl;
+ DynArray<int32> basetbl;
+ DynArray<int32> accepttbl;
+ DynArray<int32> nexttbl;
+ DynArray<int32> checktbl;
};
Modified: trafficserver/traffic/trunk/libinktomi++/ink_aiocb.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_aiocb.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_aiocb.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_aiocb.h Wed May 19 21:06:35 2010
@@ -50,7 +50,7 @@ typedef struct ink_aiocb
size_t aio_nbytes; /* length of transfer */
// TODO change to off_t
- ink_off_t aio_offset; /* file offset */
+ off_t aio_offset; /* file offset */
int aio_reqprio; /* request priority offset */
// struct sigevent aio_sigevent; /* signal number and offset */
Modified: trafficserver/traffic/trunk/libinktomi++/ink_args.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_args.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_args.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_args.cc Wed May 19 21:06:35 2010
@@ -80,7 +80,7 @@ process_arg(ArgumentDescription * argume
*(double *) argument_descriptions[i].location = atof(arg);
break;
case 'L':
- *(ink64 *) argument_descriptions[i].location = ink_atoll(arg);
+ *(int64 *) argument_descriptions[i].location = ink_atoll(arg);
break;
case 'S':
strncpy((char *) argument_descriptions[i].location, arg, atoi(argument_descriptions[i].type + 1));
@@ -119,7 +119,7 @@ show_argument_configuration(ArgumentDesc
printf("%f", *(double *) argument_descriptions[i].location);
break;
case 'L':
- printf("%lld", *(ink64 *) argument_descriptions[i].location);
+ printf("%lld", *(int64 *) argument_descriptions[i].location);
break;
case 'S':
printf("%s", (char *) argument_descriptions[i].location);
@@ -156,7 +156,7 @@ process_args(ArgumentDescription * argum
*(double *) argument_descriptions[i].location = atof(env);
break;
case 'L':
- *(ink64 *) argument_descriptions[i].location = atoll(env);
+ *(int64 *) argument_descriptions[i].location = atoll(env);
break;
case 'S':
strncpy((char *) argument_descriptions[i].location, env, atoi(argument_descriptions[i].type + 1));
@@ -226,7 +226,7 @@ usage(ArgumentDescription * argument_des
fprintf(stderr, " ");
break;
case 'L':
- fprintf(stderr, " %-9lld", *(ink64 *) argument_descriptions[i].location);
+ fprintf(stderr, " %-9lld", *(int64 *) argument_descriptions[i].location);
break;
case 'S':
if (*(char *) argument_descriptions[i].location) {
Modified: trafficserver/traffic/trunk/libinktomi++/ink_args.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_args.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_args.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_args.h Wed May 19 21:06:35 2010
@@ -42,7 +42,7 @@ struct ArgumentDescription
char key;
/*
"I" = integer
- "L" = ink64
+ "L" = int64
"D" = double (floating point)
"T" = toggle
"F" = set flag to TRUE (default is FALSE)
Modified: trafficserver/traffic/trunk/libinktomi++/ink_atomic.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_atomic.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_atomic.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_atomic.h Wed May 19 21:06:35 2010
@@ -45,36 +45,36 @@
#include "ink_apidefs.h"
-typedef volatile ink32 vink32;
-typedef volatile ink64 vink64;
+typedef volatile int32 vint32;
+typedef volatile int64 vint64;
typedef volatile void *vvoidp;
-typedef vink32 *pvink32;
-typedef vink64 *pvink64;
+typedef vint32 *pvint32;
+typedef vint64 *pvint64;
typedef vvoidp *pvvoidp;
#if defined(__SUNPRO_CC)
-typedef volatile inku32 vinku32;
+typedef volatile uint32 vuint32;
#if __WORDSIZE == 64
-typedef unsigned long inku64_s;
+typedef unsigned long uint64_s;
#else
-typedef inku64 inku64_s;
+typedef uint64 uint64_s;
#endif
-typedef volatile inku64_s vinku64_s;
-typedef vinku32 *pvinku32;
-typedef vinku64_s *pvinku64_s;
+typedef volatile uint64_s vuint64_s;
+typedef vuint32 *pvuint32;
+typedef vuint64_s *pvuint64_s;
#include <atomic.h>
-static inline ink32 ink_atomic_swap(pvink32 mem, ink32 value) { return (ink32)atomic_swap_32((pvinku32)mem, (inku32)value); }
-static inline ink64 ink_atomic_swap64(pvink64 mem, ink64 value) { return (ink64)atomic_swap_64((pvinku64_s)mem, (inku64_s)value); }
+static inline int32 ink_atomic_swap(pvint32 mem, int32 value) { return (int32)atomic_swap_32((pvuint32)mem, (uint32)value); }
+static inline int64 ink_atomic_swap64(pvint64 mem, int64 value) { return (int64)atomic_swap_64((pvuint64_s)mem, (uint64_s)value); }
static inline void *ink_atomic_swap_ptr(vvoidp mem, void *value) { return atomic_swap_ptr((vvoidp)mem, value); }
-static inline int ink_atomic_cas(pvink32 mem, int old, int new_value) { return atomic_cas_32((pvinku32)mem, (inku32)old, (inku32)new_value) == old; }
-static inline int ink_atomic_cas64(pvink64 mem, ink64 old, ink64 new_value) { return atomic_cas_64((pvinku64_s)mem, (inku64_s)old, (inku64_s)new_value) == old; }
+static inline int ink_atomic_cas(pvint32 mem, int old, int new_value) { return atomic_cas_32((pvuint32)mem, (uint32)old, (uint32)new_value) == old; }
+static inline int ink_atomic_cas64(pvint64 mem, int64 old, int64 new_value) { return atomic_cas_64((pvuint64_s)mem, (uint64_s)old, (uint64_s)new_value) == old; }
static inline int ink_atomic_cas_ptr(pvvoidp mem, void* old, void* new_value) { return atomic_cas_ptr((vvoidp)mem, old, new_value) == old; }
-static inline int ink_atomic_increment(pvink32 mem, int value) { return ((inku32)atomic_add_32_nv((pvinku32)mem, (inku32)value)) - value; }
-static inline ink64 ink_atomic_increment64(pvink64 mem, ink64 value) { return ((inku64_s)atomic_add_64_nv((pvinku64_s)mem, (inku64_s)value)) - value; }
+static inline int ink_atomic_increment(pvint32 mem, int value) { return ((uint32)atomic_add_32_nv((pvuint32)mem, (uint32)value)) - value; }
+static inline int64 ink_atomic_increment64(pvint64 mem, int64 value) { return ((uint64_s)atomic_add_64_nv((pvuint64_s)mem, (uint64_s)value)) - value; }
static inline void *ink_atomic_increment_ptr(pvvoidp mem, intptr_t value) { return (void*)(((char*)atomic_add_ptr_nv((vvoidp)mem, (ssize_t)value)) - value); }
/* not used for Intel Processors or Sparc which are mostly sequentally consistent */
@@ -87,14 +87,14 @@ static inline void *ink_atomic_increment
/* see http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html */
-static inline ink32 ink_atomic_swap(pvink32 mem, ink32 value) { return __sync_lock_test_and_set(mem, value); }
-static inline ink64 ink_atomic_swap64(pvink64 mem, ink64 value) { return __sync_lock_test_and_set(mem, value); }
+static inline int32 ink_atomic_swap(pvint32 mem, int32 value) { return __sync_lock_test_and_set(mem, value); }
+static inline int64 ink_atomic_swap64(pvint64 mem, int64 value) { return __sync_lock_test_and_set(mem, value); }
static inline void *ink_atomic_swap_ptr(vvoidp mem, void *value) { return __sync_lock_test_and_set((void**)mem, value); }
-static inline int ink_atomic_cas(pvink32 mem, int old, int new_value) { return __sync_bool_compare_and_swap(mem, old, new_value); }
-static inline ink64 ink_atomic_cas64(pvink64 mem, ink64 old, ink64 new_value) { return __sync_bool_compare_and_swap(mem, old, new_value); }
+static inline int ink_atomic_cas(pvint32 mem, int old, int new_value) { return __sync_bool_compare_and_swap(mem, old, new_value); }
+static inline int64 ink_atomic_cas64(pvint64 mem, int64 old, int64 new_value) { return __sync_bool_compare_and_swap(mem, old, new_value); }
static inline int ink_atomic_cas_ptr(pvvoidp mem, void* old, void* new_value) { return __sync_bool_compare_and_swap(mem, old, new_value); }
-static inline int ink_atomic_increment(pvink32 mem, int value) { return __sync_fetch_and_add(mem, value); }
-static inline ink64 ink_atomic_increment64(pvink64 mem, ink64 value) { return __sync_fetch_and_add(mem, value); }
+static inline int ink_atomic_increment(pvint32 mem, int value) { return __sync_fetch_and_add(mem, value); }
+static inline int64 ink_atomic_increment64(pvint64 mem, int64 value) { return __sync_fetch_and_add(mem, value); }
static inline void *ink_atomic_increment_ptr(pvvoidp mem, intptr_t value) { return __sync_fetch_and_add((void**)mem, value); }
/* not used for Intel Processors which have sequential(esque) consistency */
@@ -115,16 +115,16 @@ extern "C"
*===========================================================================*/
/* atomic swap 32-bit value */
- ink32 ink_atomic_swap(pvink32 mem, ink32 value);
+ int32 ink_atomic_swap(pvint32 mem, int32 value);
/* atomic swap a pointer */
void *ink_atomic_swap_ptr(vvoidp mem, void *value);
- ink64 ink_atomic_swap64(pvink64 mem, ink64 value);
+ int64 ink_atomic_swap64(pvint64 mem, int64 value);
#if (HOST_OS == freebsd)
- static inline int ink_atomic_cas(pvink32 mem, int old, int new_value)
+ static inline int ink_atomic_cas(pvint32 mem, int old, int new_value)
{
int result;
__asm __volatile("/* %0 %1 */; lock; cmpxchg %2,(%3)":"=a"(result)
@@ -137,7 +137,7 @@ extern "C"
return ink_atomic_cas((int *) mem, (int) old, (int) new_value);
}
- static inline int ink_atomic_increment(pvink32 mem, int value)
+ static inline int ink_atomic_increment(pvint32 mem, int value)
{
volatile int *memp = mem;
int old;
@@ -154,7 +154,7 @@ extern "C"
/* Atomic compare and swap 32-bit.
if (*mem == old) *mem = new_value;
Returns TRUE if swap was successful. */
- int ink_atomic_cas(pvink32 mem, ink32 old, ink32 new_value);
+ int ink_atomic_cas(pvint32 mem, int32 old, int32 new_value);
/* Atomic compare and swap of pointers */
int ink_atomic_cas_ptr(pvvoidp mem, void *old, void *new_value);
/* Atomic increment/decrement to a pointer. Adds 'value' bytes to the
@@ -162,20 +162,20 @@ extern "C"
void *ink_atomic_increment_ptr(pvvoidp mem, int value);
/* Atomic increment/decrement. Returns the old value */
- int ink_atomic_increment(pvink32 mem, int value);
+ int ink_atomic_increment(pvint32 mem, int value);
#endif /* freebsd vs not freebsd check */
/* Atomic 64-bit compare and swap
THIS IS NOT DEFINED for x86 */
#if (HOST_OS == freebsd)
- static inline int ink_atomic_cas64(pvink64 az, ink64 ax, ink64 ay)
+ static inline int ink_atomic_cas64(pvint64 az, int64 ax, int64 ay)
{
- unsigned long x1 = (inku64) ax;
- unsigned long x2 = ((inku64) ax) >> 32;
- unsigned long y1 = (inku64) ay;
- unsigned long y2 = ((inku64) ay) >> 32;
- register pvink64 z asm("edi") = az;
+ unsigned long x1 = (uint64) ax;
+ unsigned long x2 = ((uint64) ax) >> 32;
+ unsigned long y1 = (uint64) ay;
+ unsigned long y2 = ((uint64) ay) >> 32;
+ register pvint64 z asm("edi") = az;
int result;
__asm __volatile("lock\n" " cmpxchg8b (%1)\n" " setz %%al\n" " and $255,%%eax":"=a"(result)
:"r"(z), "a"(x1), "d"(x2), "b"(y1), "c"(y2)
@@ -183,18 +183,18 @@ extern "C"
return result;
}
- static inline ink64 ink_atomic_increment64(pvink64 mem, ink64 value)
+ static inline int64 ink_atomic_increment64(pvint64 mem, int64 value)
{
- volatile ink64 *memp = mem;
- ink64 old;
+ volatile int64 *memp = mem;
+ int64 old;
do {
old = *memp;
} while (!ink_atomic_cas64(mem, old, old + value));
return old;
}
#else /* non-freebsd for the "else" */
- int ink_atomic_cas64(pvink64 mem, ink64 old, ink64 new_value);
- ink64 ink_atomic_increment64(pvink64 mem, ink64 value);
+ int ink_atomic_cas64(pvint64 mem, int64 old, int64 new_value);
+ int64 ink_atomic_increment64(pvint64 mem, int64 value);
#endif /* freebsd vs not freebsd check */
#define INK_WRITE_MEMORY_BARRIER
Modified: trafficserver/traffic/trunk/libinktomi++/ink_base64.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_base64.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_base64.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_base64.cc Wed May 19 21:06:35 2010
@@ -223,7 +223,7 @@ ink_base64_decode(const char *inBuffer,
int inputBytesDecoded = 0;
// Figure out much encoded string is really there
- while (printableToSixBit[(inku8)inBuffer[inBytes]] <= MAX_PRINT_VAL) {
+ while (printableToSixBit[(uint8)inBuffer[inBytes]] <= MAX_PRINT_VAL) {
inBytes++;
}
Modified: trafficserver/traffic/trunk/libinktomi++/ink_file.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_file.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_file.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_file.cc Wed May 19 21:06:35 2010
@@ -31,129 +31,6 @@
#include "inktomi++.h"
-DIR *
-ink_opendir(const char *path)
-{
- return opendir(path);
-}
-
-int
-ink_closedir(DIR * d)
-{
- return closedir(d);
-}
-
-int
-ink_access_extension(char *base, char *ext, int amode)
-{
- char name[PATH_MAX];
-
- snprintf(name, sizeof(name) - 1, "%s%s", base, ext);
- name[sizeof(name) - 1] = 0;
- return (access(name, amode));
-} /* End ink_access_extension */
-
-int
-ink_readdir_r(DIR * dirp, struct dirent *entry, struct dirent **pentry)
-{
-#if (HOST_OS == freebsd)
- // this is safe for threads not accessing the same file
- // but not for interlaced accesses to the same file
- // those make little sense anyway
- // and are not used in Traffic Server
- struct dirent *d = readdir(dirp);
- if (!d) {
- errno = ENOENT;
- return -1;
- }
- memcpy(entry, d, d->d_reclen);
- *pentry = entry;
- return 0;
-#else
- return readdir_r(dirp, entry, pentry);
-#endif
-}
-
-FILE *
-ink_fopen_extension(char *base, char *ext, char *mode)
-{
- FILE *fp;
- char name[PATH_MAX];
-
- snprintf(name, sizeof(name) - 1, "%s%s", base, ext);
- name[sizeof(name) - 1] = 0;
- fp = ink_fopen(name, mode);
- return (fp);
-} /* End ink_open_extension */
-
-
-FILE *
-ink_fopen(char *name, char *mode)
-{
- FILE *fp;
-
- if ((fp = fopen(name, mode)) == NULL) {
- ink_fatal(1, "ink_fopen: can't open file '%s' for mode '%s'", name, mode);
- }
- return (fp);
-} /* End ink_fopen */
-
-
-void
-ink_fclose(FILE * fp)
-{
- int status;
-
- status = fclose(fp);
- if (status != 0) {
- ink_fatal(1, "ink_fclose: can't close file pointer");
- }
-} /* End ink_fclose */
-
-
-void
-ink_fseek(FILE * stream, long offset, int ptrname)
-{
- int status;
-
- status = fseek(stream, offset, ptrname);
- if (status != 0) {
- ink_fatal(1, "ink_fseek: can't seek");
- }
-} /* End ink_fseek */
-
-
-long
-ink_ftell(FILE * stream)
-{
- long status;
-
- status = ftell(stream);
- if (status < 0) {
- ink_fatal(1, "ink_ftell: ftell returns %ld for stream %ld", status, (long) stream);
- }
- return (status);
-} /* End ink_ftell */
-
-
-void
-ink_rewind(FILE * stream)
-{
- rewind(stream);
-} /* End ink_rewind */
-
-
-char *
-ink_fgets(char *s, int n, FILE * stream)
-{
- char *p;
-
- p = fgets(s, n, stream);
- if (p == NULL) {
- ink_fatal(1, "ink_fgets: fgets returned NULL reading %d bytes", n);
- }
- return (p);
-} /* End ink_fgets */
int
ink_fputln(FILE * stream, const char *s)
@@ -168,107 +45,6 @@ ink_fputln(FILE * stream, const char *s)
return -EINVAL;
} /* End ink_fgets */
-size_t
-ink_fread(void *ptr, size_t size, size_t nitems, FILE * stream)
-{
- size_t s;
-
- s = fread(ptr, size, nitems, stream);
- if (s == 0) {
- ink_fatal(1, "ink_fread: fread(%lu,%u,%u,%lu) returned status %d", (long) ptr, size, nitems, (long) stream, s);
- }
- return (s);
-} /* End ink_fread */
-
-
-size_t
-ink_fwrite(void *ptr, size_t size, size_t nitems, FILE * stream)
-{
- size_t s;
-
- s = fwrite(ptr, size, nitems, stream);
- if (s == 0) {
- ink_fatal(1, "ink_fwrite: fwrite(%lu,%u,%u,%lu) returned status %d", (long) ptr, size, nitems, (long) stream, s);
- }
- return (s);
-} /* End ink_fwrite */
-
-
-int
-ink_file_name_mtime(char *path, ink_time_t * tp)
-{
- int s;
- struct stat sbuf;
-
- s = stat(path, &sbuf);
- if (s != 0)
- return (0);
- *tp = sbuf.st_mtime;
- return (1);
-} /* End ink_file_name_mtime */
-
-
-int
-ink_file_name_size(char *path, off_t * op)
-{
- int s;
- struct stat sbuf;
-
- s = stat(path, &sbuf);
- if (s != 0)
- return (0);
- *op = sbuf.st_size;
- return (1);
-} /* End ink_file_name_size */
-
-
-int
-ink_file_lock_raw(int fd, int cmd, int type, off_t offset, int whence, off_t len)
-{
- struct flock lock;
-
- lock.l_type = type;
- lock.l_start = offset;
- lock.l_whence = whence;
- lock.l_len = len;
-
- return (fcntl(fd, cmd, &lock));
-} /* End ink_file_lock_raw */
-
-
-int
-ink_file_region_lock(int fd, int type, off_t start, off_t len)
-{
- int s = ink_file_lock_raw(fd, F_SETLKW, type, start, SEEK_SET, len);
- return (s < 0 ? errno : s);
-} /* End ink_file_region_lock */
-
-
-int
-ink_file_region_trylock(int fd, int type, off_t start, off_t len)
-{
- int s = ink_file_lock_raw(fd, F_SETLK, type, start, SEEK_SET, len);
- return (s < 0 ? errno : s);
-} /* End ink_file_region_lock */
-
-
-int
-ink_file_lock(int fd, int type)
-{
- int s = ink_file_lock_raw(fd, F_SETLKW, type, 0, SEEK_SET, 0);
- return (s < 0 ? errno : s);
-} /* End ink_file_lock */
-
-
-int
-ink_file_trylock(int fd, int type)
-{
- int s = ink_file_lock_raw(fd, F_SETLK, type, 0, SEEK_SET, 0);
- return (s < 0 ? errno : s);
-} /* End ink_file_trylock */
-
-
-
/*---------------------------------------------------------------------------*
int ink_file_fd_readline(int fd, int bufsz, char *buf)
@@ -312,7 +88,6 @@ ink_file_fd_readline(int fd, int bufsz,
return (i); /* number of bytes read */
} /* End ink_file_fd_readline */
-
/* Write until NUL */
int
ink_file_fd_writestring(int fd, const char *buf)
Modified: trafficserver/traffic/trunk/libinktomi++/ink_file.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_file.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_file.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_file.h Wed May 19 21:06:35 2010
@@ -65,33 +65,8 @@
//
#define INK_FILEPATH_TRUENAME 0x20
-int ink_access_extension(char *base, char *ext, int amode);
-int ink_readdir_r(DIR * dirp, struct dirent *entry, struct dirent **pentry);
-DIR *ink_opendir(const char *path);
-int ink_closedir(DIR * d);
-
-FILE *ink_fopen_extension(char *base, char *ext, char *mode);
-FILE *ink_fopen(char *name, char *mode);
-void ink_fclose(FILE * fp);
-void ink_fseek(FILE * stream, long offset, int ptrname);
-long ink_ftell(FILE * stream);
-void ink_rewind(FILE * stream);
-char *ink_fgets(char *s, int n, FILE * stream);
-int ink_fputln(FILE * stream, const char *s);
-size_t ink_fread(void *ptr, size_t size, size_t nitems, FILE * stream);
-size_t ink_fwrite(void *ptr, size_t size, size_t nitems, FILE * stream);
-int ink_file_name_mtime(char *path, time_t * tp);
-int ink_file_name_size(char *path, off_t * op);
-
-/* these routines use fcntl arguments */
-
-int ink_file_lock_raw(int fd, int cmd, int type, off_t offset, int whence, off_t len);
-int ink_file_region_lock(int fd, int type, off_t start, off_t len);
-int ink_file_region_trylock(int fd, int type, off_t start, off_t len);
-int ink_file_lock(int fd, int type);
-int ink_file_trylock(int fd, int type);
-
-int ink_file_fd_readline(int fd, int bufsz, char *buf);
+int ink_fputln(FILE *stream, const char *s);
+int ink_file_fd_readline(int fd, int bufsize, char *buf);
int ink_file_fd_writestring(int fd, const char *buf);
int ink_filepath_merge(char *buf, int bufsz, const char *rootpath,
const char *addpath, int flags);
Modified: trafficserver/traffic/trunk/libinktomi++/ink_hrtime.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_hrtime.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_hrtime.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_hrtime.cc Wed May 19 21:06:35 2010
@@ -41,7 +41,7 @@
#include "ink_unused.h" /* MAGIC_EDITING_TAG */
char *
-ink64_to_str(char *buf, unsigned int buf_size, ink64 val,
+int64_to_str(char *buf, unsigned int buf_size, int64 val,
unsigned int *total_chars, unsigned int req_width, char pad_char)
{
const int local_buf_size = 32;
@@ -51,7 +51,7 @@ ink64_to_str(char *buf, unsigned int buf
char *out_buf;
if (buf_size < 22) {
- // ink64 may not fit in provided buffer, use the local one
+ // int64 may not fit in provided buffer, use the local one
out_buf = &local_buf[local_buf_size - 1];
using_local_buffer = 1;
} else {
@@ -145,7 +145,7 @@ squid_timestamp_to_buf(char *buf, unsign
char tmp_buf[tmp_buf_size];
unsigned int num_chars_s;
- char *ts_s = ink64_to_str(tmp_buf, tmp_buf_size - 4, timestamp_sec, &num_chars_s, 0, '0');
+ char *ts_s = int64_to_str(tmp_buf, tmp_buf_size - 4, timestamp_sec, &num_chars_s, 0, '0');
ink_debug_assert(ts_s);
// convert milliseconds
@@ -153,7 +153,7 @@ squid_timestamp_to_buf(char *buf, unsign
tmp_buf[tmp_buf_size - 5] = '.';
int ms = timestamp_usec / 1000;
unsigned int num_chars_ms;
- char RELEASE_UNUSED *ts_ms = ink64_to_str(&tmp_buf[tmp_buf_size - 4],
+ char RELEASE_UNUSED *ts_ms = int64_to_str(&tmp_buf[tmp_buf_size - 4],
4, ms, &num_chars_ms, 4, '0');
ink_debug_assert(ts_ms && num_chars_ms == 4);
@@ -170,7 +170,7 @@ squid_timestamp_to_buf(char *buf, unsign
}
#ifdef USE_TIME_STAMP_COUNTER_HRTIME
-inku32
+uint32
init_hrtime_TCS()
{
int freqlen = sizeof(hrtime_freq);
@@ -183,7 +183,7 @@ init_hrtime_TCS()
}
double hrtime_freq_float = 0.5; // 500 Mhz
-inku32 hrtime_freq = init_hrtime_TCS();
+uint32 hrtime_freq = init_hrtime_TCS();
#endif
#ifdef NEED_HRTIME_BASIS
Modified: trafficserver/traffic/trunk/libinktomi++/ink_hrtime.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_hrtime.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_hrtime.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_hrtime.h Wed May 19 21:06:35 2010
@@ -36,14 +36,14 @@
#include "Compatability.h"
int squid_timestamp_to_buf(char *buf, unsigned int buf_size, long timestamp_sec, long timestamp_usec);
-char *ink64_to_str(char *buf, unsigned int buf_size, ink64 val,
+char *int64_to_str(char *buf, unsigned int buf_size, int64 val,
unsigned int *total_chars, unsigned int req_width, char pad_char);
#ifdef NEED_HRTIME
#include <time.h>
#include <sys/time.h>
#include <stdlib.h>
-typedef ink64 ink_hrtime;
+typedef int64 ink_hrtime;
#else /* !defined (NEED_HRTIME) */
#include <sys/time.h>
typedef hrtime_t ink_hrtime;
@@ -52,32 +52,12 @@ typedef hrtime_t ink_hrtime;
//////////////////////////////////////////////////////////////////////////////
//
-// Basis variables
-//
-//////////////////////////////////////////////////////////////////////////////
-#ifdef NEED_HRTIME_BASIS
-extern ink_hrtime init_hrtime_basis();
-extern timeval timeval_basis;
-extern timespec timespec_basis;
-extern ink_hrtime hrtime_offset;
-extern ink_hrtime hrtime_basis;
-#else
-static inline ink_hrtime
-init_hrtime_basis()
-{
- return 0;
-}
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
// Time Stamp Counter
//
//////////////////////////////////////////////////////////////////////////////
#ifdef USE_TIME_STAMP_COUNTER_HRTIME
extern ink_hrtime init_hrtime_TSC();
-extern inku32 hrtime_freq;
+extern uint32 hrtime_freq;
extern double hrtime_freq_float;
static inline ink_hrtime
hrtime_rdtsc()
@@ -179,7 +159,7 @@ ink_hrtime_from_nsec(unsigned int nsec)
static inline ink_hrtime
ink_hrtime_from_timeval(struct timeval *tv)
{
- ink64 usecs;
+ int64 usecs;
usecs = tv->tv_sec * 1000000 + tv->tv_usec;
return (ink_hrtime_from_usec((unsigned int) usecs));
@@ -235,7 +215,7 @@ ink_hrtime_to_nsec(ink_hrtime t)
static inline struct timeval
ink_hrtime_to_timeval(ink_hrtime t)
{
- ink64 usecs;
+ int64 usecs;
struct timeval tv;
usecs = ink_hrtime_to_usec(t);
@@ -247,7 +227,7 @@ ink_hrtime_to_timeval(ink_hrtime t)
static inline int
ink_hrtime_to_timeval2(ink_hrtime t, struct timeval *tv)
{
- ink64 usecs = ink_hrtime_to_usec(t);
+ int64 usecs = ink_hrtime_to_usec(t);
tv->tv_sec = (long) (usecs / 1000000);
tv->tv_usec = (long) (usecs % 1000000);
return 0;
Modified: trafficserver/traffic/trunk/libinktomi++/ink_inet.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_inet.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_inet.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_inet.cc Wed May 19 21:06:35 2010
@@ -99,13 +99,13 @@ host_to_ip(char *hostname)
return *(unsigned int *) he->h_addr;
}
-inku32
+uint32
ink_inet_addr(const char *s)
{
- inku32 u[4];
- inku8 *pc = (inku8 *) s;
+ uint32 u[4];
+ uint8 *pc = (uint8 *) s;
int n = 0;
- inku32 base = 10;
+ uint32 base = 10;
while (n < 4) {
@@ -142,23 +142,23 @@ ink_inet_addr(const char *s)
}
if (*pc && !ParseRules::is_wslfcr(*pc))
- return htonl((inku32) - 1);
+ return htonl((uint32) - 1);
switch (n) {
case 1:
return htonl(u[0]);
case 2:
if (u[0] > 0xff || u[1] > 0xffffff)
- return htonl((inku32) - 1);
+ return htonl((uint32) - 1);
return htonl((u[0] << 24) | u[1]);
case 3:
if (u[0] > 0xff || u[1] > 0xff || u[2] > 0xffff)
- return htonl((inku32) - 1);
+ return htonl((uint32) - 1);
return htonl((u[0] << 24) | (u[1] << 16) | u[2]);
case 4:
if (u[0] > 0xff || u[1] > 0xff || u[2] > 0xff || u[3] > 0xff)
- return htonl((inku32) - 1);
+ return htonl((uint32) - 1);
return htonl((u[0] << 24) | (u[1] << 16) | (u[2] << 8) | u[3]);
}
- return htonl((inku32) - 1);
+ return htonl((uint32) - 1);
}
Modified: trafficserver/traffic/trunk/libinktomi++/ink_inet.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_inet.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_inet.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_inet.h Wed May 19 21:06:35 2010
@@ -86,6 +86,6 @@ struct hostent *ink_gethostbyaddr_r(char
@param s IP address in the Internet standard dot notation.
*/
-inkcoreapi inku32 ink_inet_addr(const char *s);
+inkcoreapi uint32 ink_inet_addr(const char *s);
#endif // _ink_inet.h
Modified: trafficserver/traffic/trunk/libinktomi++/ink_port.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_port.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_port.h (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_port.h Wed May 19 21:06:35 2010
@@ -34,34 +34,28 @@
#include <stdio.h>
#include <sys/types.h>
+#include <stdint.h>
-typedef char ink8;
-typedef unsigned char inku8;
-typedef short ink16;
-typedef unsigned short inku16;
-typedef int ink32;
-typedef unsigned int inku32;
-typedef long long ink64;
-typedef unsigned long long inku64;
-typedef off_t ink_off_t;
-
-#define INKU64_MAX (18446744073709551615ULL)
-#define INK64_MAX (9223372036854775807LL)
-#define INK64_MIN (-INK64_MAX -1LL)
-#define INKU32_MAX (4294967295U)
-#define INK32_MAX (2147483647)
-#define INK32_MIN (-2147483647-1)
-
-#define _CRTIMP
-#define HAVE_64_BIT
+typedef char int8;
+typedef unsigned char uint8;
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+typedef unsigned int uint32;
+typedef long long int64;
+typedef unsigned long long uint64;
+
+#ifndef INT64_MIN
+#define INTU64_MAX (18446744073709551615ULL)
+#define INT64_MAX (9223372036854775807LL)
+#define INT64_MIN (-INT64_MAX -1LL)
+#define INTU32_MAX (4294967295U)
+#define INT32_MAX (2147483647)
+#define INT32_MIN (-2147483647-1)
+#endif
-#if (HOST_OS == linux) || (HOST_OS == freebsd) || (HOST_OS == darwin) || (HOST_OS == solaris)
#define POSIX_THREAD
#define POSIX_THREAD_10031c
-#else
-/* # define POSIX_THREAD */
-#error "Unknown OS!"
-#endif
#ifndef ETIME
#ifdef ETIMEDOUT
Modified: trafficserver/traffic/trunk/libinktomi++/ink_queue.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_queue.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_queue.cc (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_queue.cc Wed May 19 21:06:35 2010
@@ -51,7 +51,7 @@
#ifdef __x86_64__
-#define INK_QUEUE_LD64(dst,src) *((inku64*)&(dst)) = *((inku64*)&(src))
+#define INK_QUEUE_LD64(dst,src) *((uint64*)&(dst)) = *((uint64*)&(src))
#else
#define INK_QUEUE_LD64(dst,src) (ink_queue_load_64((void *)&(dst), (void *)&(src)))
#endif
@@ -63,8 +63,8 @@ typedef struct _ink_freelist_list
}
ink_freelist_list;
-inkcoreapi volatile ink64 fastalloc_mem_in_use = 0;
-inkcoreapi volatile ink64 fastalloc_mem_total = 0;
+inkcoreapi volatile int64 fastalloc_mem_in_use = 0;
+inkcoreapi volatile int64 fastalloc_mem_total = 0;
/*
* SANITY and DEADBEEF are compute-intensive memory debugging to
@@ -87,14 +87,14 @@ static long page_size = 8192; /* sysco
static ink_freelist_list *freelists = NULL;
-inkcoreapi volatile ink64 freelist_allocated_mem = 0;
+inkcoreapi volatile int64 freelist_allocated_mem = 0;
#define fl_memadd(_x_) \
- ink_atomic_increment64(&freelist_allocated_mem, (ink64) (_x_));
+ ink_atomic_increment64(&freelist_allocated_mem, (int64) (_x_));
//static void ink_queue_load_64(void *dst, void *src)
//{
-// ink32 src_version = (*(head_p *) src).s.version;
+// int32 src_version = (*(head_p *) src).s.version;
// void *src_pointer = (*(head_p *) src).s.pointer;
//
// (*(head_p *) dst).s.version = src_version;
@@ -104,7 +104,7 @@ inkcoreapi volatile ink64 freelist_alloc
void
ink_freelist_init(InkFreeList * f,
- const char *name, inku32 type_size, inku32 chunk_size, inku32 offset, inku32 alignment)
+ const char *name, uint32 type_size, uint32 chunk_size, uint32 offset, uint32 alignment)
{
ink_freelist_list *fll;
@@ -144,7 +144,7 @@ ink_freelist_init(InkFreeList * f,
}
InkFreeList *
-ink_freelist_create(const char *name, inku32 type_size, inku32 chunk_size, inku32 offset, inku32 alignment)
+ink_freelist_create(const char *name, uint32 type_size, uint32 chunk_size, uint32 offset, uint32 alignment)
{
InkFreeList *f = ink_type_malloc(InkFreeList);
ink_freelist_init(f, name, type_size, chunk_size, offset, alignment);
@@ -166,11 +166,11 @@ ink_freelist_new_wrap(InkFreeList * f)
void *
ink_freelist_new(InkFreeList * f)
#endif /* !INK_USE_MUTEX_FOR_FREELISTS */
-{ //static inku32 cntf = 0;
+{ //static uint32 cntf = 0;
#if (defined(USE_SPINLOCK_FOR_FREELIST) || defined(CHECK_FOR_DOUBLE_FREE))
void *foo;
- inku32 type_size = f->type_size;
+ uint32 type_size = f->type_size;
ink_mutex_acquire(&(f->freelist_mutex));
ink_assert(f->type_size != 0);
@@ -198,7 +198,7 @@ ink_freelist_new(InkFreeList * f)
* Might as well unlock the freelist mutex, since
* we're just going to do a malloc now..
*/
- inku32 alignment;
+ uint32 alignment;
#ifdef MEMPROTECT
if (type_size >= MEMPROTECT_SIZE) {
@@ -240,8 +240,8 @@ ink_freelist_new(InkFreeList * f)
do {
INK_QUEUE_LD64(item, f->head);
if (TO_PTR(FREELIST_POINTER(item)) == NULL) {
- inku32 type_size = f->type_size;
- inku32 i;
+ uint32 type_size = f->type_size;
+ uint32 i;
#ifdef MEMPROTECT
if (type_size >= MEMPROTECT_SIZE) {
@@ -288,7 +288,7 @@ ink_freelist_new(InkFreeList * f)
#if !defined(INK_USE_MUTEX_FOR_FREELISTS)
ink_atomic_increment((int *) &f->allocated, f->chunk_size);
- ink_atomic_increment64(&fastalloc_mem_total, (ink64) f->chunk_size * f->type_size);
+ ink_atomic_increment64(&fastalloc_mem_total, (int64) f->chunk_size * f->type_size);
#else
f->allocated += f->chunk_size;
fastalloc_mem_total += f->chunk_size * f->type_size;
@@ -312,7 +312,7 @@ ink_freelist_new(InkFreeList * f)
}
#if !defined(INK_USE_MUTEX_FOR_FREELISTS)
ink_atomic_increment((int *) &f->count, f->chunk_size);
- ink_atomic_increment64(&fastalloc_mem_in_use, (ink64) f->chunk_size * f->type_size);
+ ink_atomic_increment64(&fastalloc_mem_in_use, (int64) f->chunk_size * f->type_size);
#else
f->count += f->chunk_size;
fastalloc_mem_in_use += f->chunk_size * f->type_size;
@@ -322,7 +322,7 @@ ink_freelist_new(InkFreeList * f)
SET_FREELIST_POINTER_VERSION(next, *ADDRESS_OF_NEXT(TO_PTR(FREELIST_POINTER(item)), f->offset),
FREELIST_VERSION(item) + 1);
#if !defined(INK_USE_MUTEX_FOR_FREELISTS)
- result = ink_atomic_cas64((ink64 *) & f->head.data, item.data, next.data);
+ result = ink_atomic_cas64((int64 *) & f->head.data, item.data, next.data);
#else
f->head.data = next.data;
result = 1;
@@ -345,7 +345,7 @@ ink_freelist_new(InkFreeList * f)
ink_assert(!((uintptr_t)TO_PTR(FREELIST_POINTER(item))&(((uintptr_t)f->alignment)-1)));
ink_atomic_increment((int *) &f->count, 1);
- ink_atomic_increment64(&fastalloc_mem_in_use, (ink64) f->type_size);
+ ink_atomic_increment64(&fastalloc_mem_in_use, (int64) f->type_size);
return TO_PTR(FREELIST_POINTER(item));
#endif /* #if (defined(USE_SPINLOCK_FOR_FREELIST) || defined(CHECK_FOR_DOUBLE_FREE)) */
@@ -441,7 +441,7 @@ ink_freelist_free(InkFreeList * f, void
SET_FREELIST_POINTER_VERSION(item_pair, FROM_PTR(item), FREELIST_VERSION(h));
INK_MEMORY_BARRIER;
#if !defined(INK_USE_MUTEX_FOR_FREELISTS)
- result = ink_atomic_cas64((ink64 *) & f->head, h.data, item_pair.data);
+ result = ink_atomic_cas64((int64 *) & f->head, h.data, item_pair.data);
#else
f->head.data = item_pair.data;
result = 1;
@@ -451,7 +451,7 @@ ink_freelist_free(InkFreeList * f, void
while (result == 0);
ink_atomic_increment((int *) &f->count, -1);
- ink_atomic_increment64(&fastalloc_mem_in_use, -(ink64) f->type_size);
+ ink_atomic_increment64(&fastalloc_mem_in_use, -(int64) f->type_size);
#endif
}
@@ -515,7 +515,7 @@ ink_freelists_dump(FILE * f)
ink_freelist_create("<unknown>", sizeof(T), n, (uintptr_t)&((T *)0)->next, 4)
void
-ink_atomiclist_init(InkAtomicList * l, const char *name, inku32 offset_to_next)
+ink_atomiclist_init(InkAtomicList * l, const char *name, uint32 offset_to_next)
{
#if defined(INK_USE_MUTEX_FOR_ATOMICLISTS)
ink_mutex_init(&(l->inkatomiclist_mutex), name);
@@ -543,7 +543,7 @@ ink_atomiclist_pop(InkAtomicList * l)
SET_FREELIST_POINTER_VERSION(next, *ADDRESS_OF_NEXT(TO_PTR(FREELIST_POINTER(item)), l->offset),
FREELIST_VERSION(item) + 1);
#if !defined(INK_USE_MUTEX_FOR_ATOMICLISTS)
- result = ink_atomic_cas64((ink64 *) & l->head.data, item.data, next.data);
+ result = ink_atomic_cas64((int64 *) & l->head.data, item.data, next.data);
#else
l->head.data = next.data;
result = 1;
@@ -575,7 +575,7 @@ ink_atomiclist_popall(InkAtomicList * l)
return NULL;
SET_FREELIST_POINTER_VERSION(next, FROM_PTR(NULL), FREELIST_VERSION(item) + 1);
#if !defined(INK_USE_MUTEX_FOR_ATOMICLISTS)
- result = ink_atomic_cas64((ink64 *) & l->head.data, item.data, next.data);
+ result = ink_atomic_cas64((int64 *) & l->head.data, item.data, next.data);
#else
l->head.data = next.data;
result = 1;
@@ -618,7 +618,7 @@ ink_atomiclist_push(InkAtomicList * l, v
SET_FREELIST_POINTER_VERSION(item_pair, FROM_PTR(item), FREELIST_VERSION(head));
INK_MEMORY_BARRIER;
#if !defined(INK_USE_MUTEX_FOR_ATOMICLISTS)
- result = ink_atomic_cas64((ink64 *) & l->head, head.data, item_pair.data);
+ result = ink_atomic_cas64((int64 *) & l->head, head.data, item_pair.data);
#else
l->head.data = item_pair.data;
result = 1;
@@ -652,7 +652,7 @@ ink_atomiclist_remove(InkAtomicList * l,
head_p next;
SET_FREELIST_POINTER_VERSION(next, item_next, FREELIST_VERSION(head) + 1);
#if !defined(INK_USE_MUTEX_FOR_ATOMICLISTS)
- result = ink_atomic_cas64((ink64 *) & l->head.data, head.data, next.data);
+ result = ink_atomic_cas64((int64 *) & l->head.data, head.data, next.data);
#else
l->head.data = next.data;
result = 1;