원형큐 형태의 캐싱버퍼 구현~

네트워크(TCP) 프로그램을 하다보면, 데이터를 받아 관리하는 버퍼가 필요하게 된다. 이 버퍼을 구현하기위해
많은 방법이 존재하지만, 대부분의 개발자는 원형큐 형태의 버퍼를 선호하는 경향이 있다.

그런데, 캐싱버퍼 구현에 있어 가장 중요한 부분이 바로 데이터를 얼마나 빨리 저장하고, 읽어 들이느냐에 대한 구현 방법이다. -- 이러한 처리를 위한 일부 개발자는 바이트단위로 복사하는 방법을 사용하기도 하고, 일부 개발자는 블럭단위로 복사하기도 한다.

나는, 여기에서 이 부분을 구현하기 위해 memcpy() 함수를 사용하였다. memcpy()함수는 데이터를 가장 빨리 복사하기 위해 내부적으로 레지스터리 단위로 데이터를 복사한다.

그럼 가장 먼저 데이터를 저장하는 부분부터 보자~

int cache_put( struct cache *c, const char *buffer, int size)
{
 c->len += size;
 if ((c->ca.end - c->ca.begin) < c->len)
  return -1;
 else {
  register int npart;

  if ((npart = (int)(c->ca.end - c->w_ptr)) > size)
   memcpy( c->w_ptr, buffer, size);
  else {
   memcpy( c->w_ptr, buffer, npart);
   if ((size -= npart) > 0)
    memcpy( c->ca.begin, buffer + npart, size);
   c->w_ptr = c->ca.begin;
  } c->w_ptr += size;
 } return c->len;
}

이 함수는 함수명 처럼, 데이터를 복사한다. 또한, 하나의 버퍼를 통해 입/출력이 가능해야 하므로 read ptr과 write ptr을 가지고 있다.

struct cache {
 char *r_ptr, *w_ptr;
 struct {
  char *begin, *end;
 } ca; int len;
};

와 같이.. 물론, 데이터를 read하는 함수도 cache_put()함수의 반대로 되어 있다고 보면 적당하겠다.

static char *cache_offsetof( struct cache *c, int offset)
{
 int n;

 if ((n = (int)(c->ca.end - c->r_ptr)) > offset)
  return c->r_ptr + offset;
 return c->ca.begin + (offset - n);
}

int cache_get( struct cache *c, char *buffer, int size, int offset)
{
 if (c->len < (size + offset))
  return -1;
 else {
  char *ptr = cache_offsetof( c, offset);

  c->len -= (size + offset);
  if ((offset = (int)(c->ca.end - ptr)) > size)
   memcpy( buffer, ptr, size);
  else {
   memcpy( buffer, ptr, offset); {
    ptr = c->ca.begin;
    size = size - offset;
   } memcpy( buffer + offset, ptr, size);
  } c->r_ptr = ptr + size;
 } return c->len;
}

특이하게 cache_get()함수에는 접근 offset을 별도로 두고 있다, 필요에 따라 특정 데이터 범위를 SKIP하기 위함이다

마지막으로 사용되는 데이터 구조체를 생성하는 방법을 알아보자. 난, 내부에서 메모리를 할당하지 않고 할당된 버퍼를 외부로 부터 받도록 하였다. 굳이 이렇게 생성한 이유는 입/출력 버퍼를 한번에 할당하여 버퍼를 두개로 쪼개어 사용할수 있도록 하기 위해서 이다.

int cache_sizeof( int c_size)
{
 return (sizeof(struct cache) + sizeof(CRITICAL_SECTION) + c_size);
}
struct cache *cache_init( int c_size, char **buffer)
{
 struct cache *c;

 if ((c_size <= 0) || (buffer == NULL))
  return NULL;
 else {
  CRITICAL_SECTION *lock = (CRITICAL_SECTION *)(*buffer);

  InitializeCriticalSection( lock);
  c = (struct cache *)(lock + 1); {
   c->ca.end = (c->w_ptr = (c->r_ptr = (c->ca.begin = (char *)(c + 1)))) + c_size;
   c->len = 0;
  } (*buffer) = c->ca.end;
 } return c;
}

static CRITICAL_SECTION *cache_getlock( struct cache *c)
{
 return (CRITICAL_SECTION *)(((char *)c) - sizeof(CRITICAL_SECTION));
}

void cache_exit( struct cache *c) { DeleteCriticalSection( cache_getlock(c)); }

void enter_cachelock( struct cache *c) { EnterCriticalSection( cache_getlock(c)); }
void leave_cachelock( struct cache *c) { LeaveCriticalSection( cache_getlock(c)); }

보면, 알겠지만 cache_init()시 별도의 lock버퍼를 메모리의 가장 처음에 위치하도록 하고, 그 이후부터 데이터를 저장하도록 하였다. 어찌 보면 불 필요할수 있으나  예전에 제작된 소스와의 호환성 때문에 개발시 이렇게 만들었다. 또한, lock이 필요없는 상황이나, lock의 방식 변경이 필요할때 원형을 수정하지 않고 변경하기 위함도 있다.

필요에 따라 수정해 사용해도 무방할듯 하다.

그외의 필요함수라면, 캐싱된 버퍼의 데이터를 offset 증가 없이 바로 읽는 부분에 대한 함수가 필요한게 되는데 이함수는 주로 저장된 데이터로 부터 필요한 데이터가 존재하는지 검사하기 위한 PEEK기능이라고 보면 좋을듯 하다~

int cache_look( struct cache *c, char *buffer, int size, int offset)
{
 if (c->len < (offset + size))
  return -1;
 else {
  char *ptr = cache_offsetof( c, offset);

  if ((offset = (int)(c->ca.end - ptr)) > size)
   memcpy( buffer, ptr, size);
  else {
   memcpy( buffer, ptr, offset);
   memcpy( buffer + offset, c->ca.begin, size - offset);
  }
 } return size;
}

이 부분이 바로 해당 데이터를 offset증가 없이 읽는 부분이다.

개발에 도움이 되길~ 간단한 코드 이므로 별도의 소스 설명은 생각^^;