KR20070104566A - 네트워크에서 동적으로 발생된 객체들의 캐싱을 수행하는시스템 및 방법 - Google Patents

Abstract

본 발명은 동적으로 발생된 데이터를 저장 및 서빙하는 캐시 메모리들의 능력을 증가시킨다. 본 발명은 또한 캐시가 다양하고 상이한 애플리케이션 요청 타입을 효과적으로 처리하는 것을 가능하게 함으로써, 애플리케이션 성능이 향상되고 캐시로부터 서빙되는 데이터의 새로움을 보존하기 위한 관리가 수월해진다. 본 발명은, 객체를 처음으로 발생하는 애플리케이션 서버에 의해 실행되는 프로세싱을 복제하지 않는 방식으로 데이터를 이해 및 처리하는 능력을 포함하는 것 이외에, 이러한 애플리케이션 서버들의 행위를 효과적으로 예측하기 위해 발견적인 방법(heuristics)의 이용에 의해 동적 콘텐트를 캐싱하는 효과적인 접근법을 제공한다. 본 발명의 이들 기술은 또한 동적 캐싱의 이용을 증가시키고, 이에 따라 네트워크뿐만 아니라 내재하는 애플리케이션 인프라구조의 성능의 개선에 기여한다.

데이터, 캐시 메모리, 클라이언트, 시작 서버, 버퍼, 객체, 응답

Description

네트워크에서 동적으로 발생된 객체들의 캐싱을 수행하는 시스템 및 방법{SYSTEMS AND METHODS FOR PERFORMING CACHING OF DYNAMICALLY GENERATED OBJECTS IN A NETWORK}

본 출원은 2005년 6월 29일에 출원되고 발명의 명칭이 "데이터 통신 네트워크에서 통합 캐싱을 수행하는 방법 및 장치"인 미국 특허 출원 제11/169,002호 및 2005년 1월 24일에 출원되고 발명의 명칭이 "가상 전용 네트워크를 구축하는 시스템 및 방법"인 미국 특허 출원 제11/039,946호에 대한 우선권을 주장하며, 이 두 미국 출원은 여기서 참조 문헌으로서 포함된다.

본 발명은 일반적으로 네트워크에서 데이터를 캐싱하는 것에 관한 것이다. 특히, 본 발명은 네트워크에서 동적으로 발생된 객체들의 캐싱을 수행하기 위한 장치, 시스템, 및 방법에 관한 것이다.

네트워크 트래픽의 성장 속도는 그 트래픽을 운반하는 인프라구조를 계속 변화시킨다. 네트워크 운영자들이 캐싱 기술의 발전을 포함한 이 증가 문제를 처리할 수 있도록 각종 해결책들이 생겨났다. 전통적인 캐싱을 이용하여, 정적 콘텐트가 재사용되어 서버 인프라구조에 부담을 주지 않고 다수의 클라이언트에게 서빙될 수 있다. 또한, 캐시 메모리들은 정적 콘텐트를 상기 최종 사용자에 보다 가깝게 저장하는 것을 가능하게 함으로써, 응답 시간을 향상시키고, 동시에 서버 인프라구조 부담을 줄인다. 줄어든 응답 시간 및 줄어든 서버 인프라구조 부하는 이러한 인프라구조의 대역폭 및 처리 요건을 감소시킨다.

그러나, 네트워크들을 통해 전달되는 콘텐트의 양이 증가하고, 그 콘텐트는 동적으로 발생되며 기업 컴퓨팅 솔루션들 및 복잡한 인터넷 애플리케이션들에 의해 생성되는 네트워크 트래픽의 많은 부분을 포함한다. 동적으로 발생된 콘텐트는 객체가 요청될 때 서버에 의해 발생되는 콘텐트이고, 종종 상기 클라이언트로부터 수신되는 입력에 기초한다. 그러므로, 이는 시간에 따라 그리고 상기 발생 시스템에 대해 행해진 입력에 대해 빈번하게 변화한다. 동적 콘텐트의 일반적인 예로는, 클라이언트가 또는 데이터베이스에 의해 행해진 주식 시세 요청이 탐색되는 경우를 들 수 있다. 각 예에서, 응답 객체는 특정 클라이언트 요청 수신 후 실시간으로 발생된다.

동적으로 발생된 콘텐트를 캐싱함에 있어 여러 가지가 문제가 있다. 예컨대, 동적으로 발생된 콘텐트를 캐싱하기 위한 일반적인 규격 또는 사항이 없다. 동적으로 발생된 객체를 캐싱할 수 있는지를 지정하기 위한 규격이 없으므로, 이러한 객체들은 일반적으로 캐싱 불가능으로 취급된다. 다른 문제는 동적으로 발생된 객체를 발생하는데 이용된 잠재 데이터에 대한 변화가 불규칙적이고 예측 불가능할 수 있으므로, 동적으로 발생된 객체의 "새로움"의 유효성을 결정하는 것이다.

상기한 문제 외에도, 동적으로 발생된 콘텐트에 대한 요청은 또한 일반적으로 정적 콘텐트에 대한 요청보다 복잡하다. 동적 요청은 종종, 이러한 요청에 관련 된 적절한 객체를 식별하기 위해 캐시에 의해 이용되는 적용 가능 파라미터를 식별하기 위하여, 목적지 애플리케이션에 의해 처리 또는 분석될 필요가 있는 정보 스트링을 포함한다. 그러나, 이들 파라미터는 클라이언트에 의해 논리적이거나 일관된 순서로 요청에 배치되지 않는다. 동적으로 발생된 객체들 중 어느 객체가 요청에 의해 식별되는지를 판단하기 위해, 이러한 요청 각각은 규준화되어야 한다(즉, 파라미터를 임의적이지 않은 순서로 배치하여야 한다).

또한, 요청을 동적으로 발생된 객체에 매칭시키는 것은 애플리케이션에 의해 행해지는 일정한 처리를 훈련된 추측으로 복제하거나 예상할 필요가 있을 수 있으므로 동적으로 발생된 콘텐트에 대해 훨씬 더 복잡한 작업이 된다. 이 복제 또는 추측은 캐시에 저장된 객체가 들어오는 특별한 요청에 대한 서빙에 적합한지를 판단하는 것이 필요하다. 애플리케이션들 자체의 복잡성 때문에 그리고 응답의 콘텐트가 요청의 두 콘텐트의 함수일 뿐만 아니라, 사용자-아이덴티티(요청에 존재할 수 있고 없을 수도 있음), 하루 중의 시간, 사용자 데이터베이스의 현재 상태 및 무수한 다른 인자들과 같은 다른 외부 변수일 수 있기 때문에 복잡성이 생긴다.

정리하면, 캐싱은 원래 정적 객체들의 캐싱을 중심으로 개발되었다. 인터넷 및 애플리케이션들이 동적으로 발생된 콘텐트를 전달하는 것에 더욱더 의존하게 됨에 따라, 동적 콘텐트에 대한 캐싱의 혜택을 늘리고, 전통적인 캐싱 기술에 대해 이러한 콘텐트가 제시하는 다양한 도전들을 해결하는 솔루션이 필요하게 되었다.

본 발명은 동적으로 발생된 데이터를 저장 및 서빙하는 캐시 메모리들의 능력을 증가시킨다. 본 발명은 또한 캐시가 다양하고 상이한 애플리케이션 요청 타입을 효과적으로 처리하는 것을 가능하게 함으로써, 애플리케이션 성능이 향상되고 캐시로부터 서빙되는 데이터의 새로움을 보존하기 위한 관리가 수월해진다. 본 발명은, 객체를 처음으로 발생하는 애플리케이션 서버에 의해 실행되는 프로세싱을 복제하지 않는 방식으로 데이터를 이해 및 처리하는 능력을 포함하는 것 이외에, 이러한 애플리케이션 서버들의 행위를 효과적으로 예측하기 위해 발견적인 방법(heuristics)의 이용에 의해 동적 콘텐트를 캐싱하는 효과적인 접근법을 제공한다. 본 발명의 이들 기술은 또한 동적 캐싱의 이용을 증가시키고, 이에 따라 네트워크뿐만 아니라 내재하는 애플리케이션 인프라구조의 성능의 개선에 기여한다.

일 실시예에서, 본 발명은 동적으로 발생된 객체들을 캐시에 캐싱 및 유지하는 방법 및 시스템에 관한 것이다. 본 발명의 기술들은 객체, 예컨대 시작 서버로부터 이전에 서빙되어 캐시에 저장된 동적으로 발생된 객체를 무효화하라는 무효화 명령을 캐시에서 수신하는 단계를 포함한다. 동적으로 발생된 객체는 시작 서버로부터 캐싱 가능으로 식별되지 않을 수도 있다. 캐시에 의해 수신된 무효화 명령은 캐싱된, 동적으로 발생된 객체를 식별한다. 무효화 명령에 응답하여, 캐시는 캐싱된 동적으로 발생된 객체를 무효로 마킹하고 객체를 캐시로부터 플러싱(flush)한다.

다른 실시예에서, 본 발명은 또한 객체 결정인자를 이용하여 캐싱된 동적으로 발생된 객체들을 식별하기 위한 기술들을 제공한다. 캐시는 클라이언트와 서버 간의 통신을 인터셉트할 수 있고, 객체 결정인자를 식별하기 위해 통신을 분석할 수 있다. 객체 결정인자는 이전에 서빙되어 캐시에 저장된 객체를 식별할 수 있다. 캐시는 객체 결정인자에 의해 식별된 객체에 대한 변화가 시작 서버에서 일어났는지 아니면 일어날 것인지를 객체 결정인자로부터 판단한다. 변화가 일어났거나 일어날 것이면, 캐시는 객체 결정인자에 의해 식별된 객체를 무료로 마킹한다. 일단 객체가 무효로 마킹되면, 캐시는 무효 객체를 플러싱할 수 있고 시작 서버로부터 객체를 검색할 수 있다.

또한, 본 발명의 실시예들은 상기 방법들을 동적으로 발생된 객체들의 그룹들에 적용한다. 예컨대, 이전에 서빙된 동적으로 발생된 객체들의 그룹이 캐시에서 형성된다. 객체 그룹은 적어도 하나의 객체 결정인자와 연관된다. 그룹의 레코드가 캐시에 유지되고 객체 결정인자와 연관될 수 있다. 이전에 서빙된 객체들의 그룹은, 캐시에 의해 인터셉트된 통신의 식별된 객체 결정인자가 그룹의 하나 이상의 객체들에 대한 변화가 시작 서버에서 일어났는지 아니면 일어날 것인지를 지시하면, 무효로 마킹된다.

일 양태에서,본 발명은 캐싱 가능한 것으로 식별되지 않은 동적으로 발생된 객체를 캐싱하는 방법에 관한 것이다. 상기 방법은 캐싱 가능한 것으로 식별되지 않은 동적으로 발생된 객체를 캐시에 저장하고, 상기 캐시가 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 요청을 수신하는 단계를 포함한다. 이 요청에 응답하여, 캐시가 상기 캐싱된 동적으로 발생된 객체를 무효로서 마킹한다. 캐시는 시작 서버와 클라이언트 간의 통신시 임의 장치, 예컨대 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 상에서 동작될 수 있다.

일부 실시예들에서, 본 발명의 상기 방법은 상기 시작 서버가 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 단계를 포함한다. 다른 실시예에서, 상기 시작 서버는 상기 시작 서버에서의 상기 동적으로 발생된 객체에 대한 변화에 응답하여 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 자동으로 요청한다. 다른 실시예에서, 상기 클라이언트는 상기 동적으로 발생된 객체를 수신하기 위해 상기 시작 서버와 통신한다. 또 다른 실시예에서, 외부 관리 제어기가 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청한다.

일 실시예에서, 본 발명의 방법은 무효로 마킹된 상기 캐싱된 동적으로 발생된 객체를 상기 캐시로부터 플러싱(flushing)하는 단계를 포함한다. 다른 실시예에서, 상기 캐시는 상기 동적으로 발생된 객체를 캐싱하는 10 밀리초 또는 10 밀리초보다 짧은 시간 내에서 무효화하라는 요청을 수신한다. 일부 실시예들에서, 상기 캐시는 캐싱된 객체의 매우 짧은 만기, 예컨대 10 밀리초 또는 10 밀리초보다 짧은 만기의 만료에 응답하여 상기 캐싱된 동적으로 발생된 객체를 무효화한다.

다른 양태에서, 본 발명은 동적으로 발생된 객체들의 그룹을 캐싱하는 방법에 관한 것이다. 일부 실시예들에서, 상기 객체 그룹은 캐싱 가능한 것으로 식별되지 않은 적어도 하나의 객체를 갖는다. 상기 방법은 시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹을 캐시에서 식별하되, 상기 동적으로 발생된 객체들 중 적어도 하나는 캐싱 가능한 것으로 식별되지 않은 단계를 포함한다. 상기 캐시는 상기 그룹을 객체 결정인자와 연관시킨다. 상기 방법은 또한 상기 캐시가 상기 그룹의 객체 결정인자를 식별하는 통신을 인터셉트하고, 상기 그룹의 객체들 중 하나의 객체에 대한 변화가 상기 시작 서버상에서 막 일어나려하는지 아니면 일어났는지를 나타내는 단계를 포함한다. 일 실시예에서, 본 발명의 방법은 상기 캐시가 상기 통신의 수신에 응답하여 상기 동적으로 발생된 객체들의 그룹을 무효로 마킹하는 단계를 포함한다.

또한, 본 발명의 일부 실시예들에서,상기 캐시는 무효로 마킹된 객체 그룹을 플러싱할 수 있다. 다른 실시예에서, 상기 동적으로 발생된 객체들의 그룹은 미리 지정된다. 다른 실시예에서, 상기 방법은 상기 동적으로 발생된 객체들의 그룹을 자동으로 식별하고, 상기 객체 결정인자를 규칙에 따라 상기 그룹과 연관시킨다.

일 양태에서, 본 발명은 동적으로 발생된 객체들의 캐시를 유지하는 다른 방법에 관한 것이다. 본 발명의 이 방법은 캐시가 클라이언트와 시작 서버 간의 통신, 예컨대 시작 서버로의 동적으로 발생된 객체에 대한 클라이언트의 요청을 인터셉트한다. 동적으로 발생된 객체는 시작 서버에 의해 미리 서빙되어 캐시에 저장되어 있을 수 있다. 상기 방법에서, 상기 캐시가 상기 시작 서버에서 동적으로 발생된 객체에 대한 변화가 일어났는지 아니면 일어날 것인지를 나타내는 객체 결정인자를 상기 통신에서 식별하고, 상기 캐시가 상기 캐시에 저장된 상기 동적으로 발생된 객체를 무효로 마킹한다. 다음에, 상기 방법은 상기 시작 서버로부터 상기 동적으로 발생된 객체를 얻는다.

상기 방법의 일 실시예에서, 상기 캐시는 상기 동적으로 발생된 객체를 플러싱한다. 다른 실시예에서, 상기 캐시는 상기 동적으로 발생된 객체를 상기 시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹과 연관시키고, 상기 그룹을 상기 객체 결정인자와 연관시키고, 상기 통신에 응답하여 상기 동적으로 발생된 객체들의 그룹을 무효로 마킹한다. 일부 실시예들에서, 상기 동적으로 발생된 객체는 캐싱 가능한 것으로 식별되지 않는다. 다른 실시예에서, 상기 캐시는 무효로 마킹된 상기 동적으로 발생된 객체들의 그룹을 플러싱한다. 상기 동적으로 발생된 객체들의 그룹은 미리 지정될 수도 있고, 규칙에 따라 객체 결정인자를 통해 자동으로 식별될 수도 있다.

상기 방법의 일부 실시예들에서, 상기 클라이언트는 상기 객체 결정인자를 미리 정의된 스트링으로서 상기 통신에 삽입한다. 다른 실시예들에서, 상기 캐시는 상기 동적으로 발생된 객체와 연관된 미리 정의된 발견적인(heuristic) 규칙에 기초하여 상기 객체 결정인자를 식별한다. 일 실시예에서, 상기 캐시는 다음의 통신 요소들, 즉 USERID, IP 주소, TCP 포트, HTTP 헤더, 커스텀 HTTP 헤더, 클라이언트 URL, 쿠키 헤더, URL 질의 스트링 및 POST 바디 중 하나로부터 상기 객체 결정인자를 선택한다. 상기 캐시는 또한, 사용자-구성된 무효화 정책에 기초하여 상기 객체 결정인자를 상기 통신으로부터 추출할 수 있다.

다른 실시예에서,본 발명의 방법은 상기 객체 결정인자를 상기 캐시에 저장된 하나 이상의 객체들 또는 객체 그룹들과 연관시키기 위해 상기 캐시 내에 테이블을 유지하는 단계를 포함한다. 일부 실시예들에서, 상기 방법은 지능형 통계 엔진이 상기 캐시에 저장할 한 세트의 동적으로 발생된 객체들을 식별하기 위해 상기 클라이언트로부터의 통신을 검사하는 단계를 포함한다. 상기 캐시는 상기 캐시에 저장된 객체들을 콘텐트 그룹에 연관시킬 수 있다. 상기 콘텐트 그룹은 구체화 번호(incarnation number)를 인덱스로서 가진 해쉬 테이블에 의해 표현될 수 있다. 다른 실시예들에서, 상기 캐시는 상기 동적으로 발생된 객체에 대한 변화를 결정하기 위해 상기 통신을 통해 식별된 상기 동적으로 발생된 객체에 대해 해쉬 알고리즘을 수행한다.

일부 양태들에서, 본 발명은 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐싱하는 시스템에 관한 것이고, 상기 시스템은 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐시에 저장하되, 상기 동적으로 발생된 객체는 시작 서버로부터 서빙되는 수단; 및 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 요청을 상기 캐시에 의해 수신하는 수단을 포함한다. 또한, 상기 시스템은 상기 요청에 응답하여 상기 캐싱된 동적으로 발생된 객체를 무효로서 상기 캐시에 의해 마킹하는 수단을 포함한다.

다른 양태들에서,본 발명은 객체들,예컨대 동적으로 발생된 객체들의 그룹을 캐싱하는 시스템에 관한 것이다. 일부 실시예들에서, 동적으로 발생된 객체들은 캐싱 가능으로 식별되지 않은 적어도 하나의 객체를 갖는다. 상기 시스템은 시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹을 캐시에서 식별하되, 상기 동적으로 발생된 객체들 중 적어도 하나는 캐싱 가능으로 식별되지 않은 수단; 및 상기 캐시에 의해, 상기 그룹을 객체 결정인자와 연관시키는 수단을 포함한다. 상기 시스템은 또한, 상기 캐시에 의해, 상기 그룹의 객체 결정인자를 식별하는 통신을 인터셉트하고, 상기 그룹의 객체들 중 하나의 객체에 대한 변화가 상기 시작 서버상에서 막 일어나려하는지 아니면 일어났는지를 나타내는 수단을 포함한다.

일 양태에서, 본 발명은 동적으로 발생된 객체들의 캐시를 유지하는 시스템에 관한 것이다. 상기 시스템은 캐시가 클라이언트와 시작 서버 간의 통신을 인터셉트하는 수단을 포함한다. 상기 시스템은 상기 캐시가 상기 시작 서버에서 동적으로 발생된 객체에 대한 변화가 일어났는지 아니면 일어날 것인지를 나타내는 객체 결정인자를 상기 통신에서 식별하는 수단; 및 상기 캐시가 상기 캐시에 저장된 상기 동적으로 발생된 객체를 무효로 마킹하는 수단을 또한 포함한다. 일부 실시예들에서, 상기 시스템은 또한 상기 시작 서버로부터 상기 동적으로 발생된 객체를 얻는 수단을 포함한다.

다른 양태에서, 본 발명은 캐시에 저장된 동적으로 발생된 객체들의 그래눌러 무효화를 제공하는 방법 및 시스템에 관한 것이다. 본 발명의 기술들은, 그래눌러 시간 간격, 예컨대 패킷 처리 엔진의 패킷 처리 타이머에 의해 제공되는 시간 간격의 그래뉼래러티를 미세화하기 위해, 캐시에 의해 저장된 객체들의 만료 시간을 구성하는 능력을 포함한다. 이와 같이, 본 발명은 객체들을, 매우 짧은 시간 간격으로 다운된 만료 시간으로 캐싱할 수 있다. 이 특징은 "무효화 그래뉼래러티(invalidation granularity)"라고 한다. 만료 시간에 이 미세 그래뉼래러티를 제공함으로써, 본 발명의 캐시는 빈번하게, 종종 1 초 내에서 여러 번 변화하는 객체들을 캐싱 및 서빙할 수 있다. 한가지 기술은, 10 ms로 다운된 무효화 또는 만기 그래뉼래러티를 허용하기 위해 밀리초 정도의 시간 증분으로 동작할 수 있는 본 발명의 장치에 의해 사용되는 패킷 처리 타이머를 레버리징하는 것이다. 본 발명의 통합 캐시가 패킷 처리 엔진의 패킷 처리 타이머에 응답하여 캐시 동작들을 수행함에 따라, 객체들의 무효화는 밀리초 정도의 시간 기간 내에서, 그리고 패킷 처리 타이머에 의해 제공된 시간 간격, 예컨대 10 ms 정도의 만기를 가진 객체들의 경우에 일어날 수 있다

일 양태에서, 본 발명은 패킷 처리 타이머의 신호에 응답하여 상기 캐시에 캐싱된 동적으로 발생된 객체를 무효화하는 방법에 관한 것이다. 상기 방법은 적어도 하나의 동적으로 발생된 객체를 구비하는 네트워크 패킷들을 처리하고, 상기 적어도 하나의 동적으로 발생된 객체를 캐시에 저장하는 장치의 패킷 처리 엔진에서 수행될 수 있다. 상기 방법은 네트워크 패킷을 처리하기 위해 패킷 처리 타이머로부터 제1 신호를 수신하는 단계; 상기 신호에 응답하여 상기 네트워크 패킷을 처리하는 단계; 및 캐싱된 동적으로 발생된 객체가 무효임을 나타내는 제2 신호를 캐시에 전송하는 단계를 포함한다. 일 실시예에서, 상기 제2 신호는 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 무효화 명령을 제공한다. 다른 실시예에서, 상기 제2 신호는 상기 캐싱된 동적으로 발생된 객체의 만기의 만료를 제공한다.

일부 실시예들에서, 제2 신호는 상기 네트워크 패킷의 처리 동안에 전송되고, 다른 실시예들에서는 제2 신호가 상기 네트워크 패킷의 처리 완료시 전송된다. 본 발명의 일 실시예에서, 상기 패킷 처리 타이머는 1 밀리초 이상의 시간 증분으로 동작한다. 상기 패킷 처리 타이머는 10 밀리초와 동일하거나 짧은 만기 시간에 캐시에 저장된 객체를 무효화하기 위한 시간 증분으로 동작한다. 상기 방법은 상기 캐시가 상기 캐싱된 동적으로 발생된 객체를 무효로 마킹하는 단계를 포함할 수 있다. 일 실시예에서, 상기 방법은 동적으로 발생된 객체를 포함하는 상기 네트워크 패킷을 시작 서버로부터 송신하는 단계를 포함한다.

패킷 처리 엔진을 가진 상기 장치는 1) 브리지, 2) 라우터, 3) 스위치, 및 4) SSL VPN 장치 중 어느 것을 포함할 수 있다. 일부 실시예들에서, 상기 장치의 커널 공간에서 상기 캐시, 상기 패킷 처리 엔진, 또는 상기 패킷 처리 타이머가 동작한다. 일부 실시예들에서, 상기 방법은 시작 서버로부터의 상기 동적으로 발생된 객체를 동적으로 발생하고 서빙하는 시간 기간보다 짧거나 같은 상기 캐싱된 동적으로 발생된 객체의 만기 시간 간격을 상기 패킷 처리 타이머를 통해 제공하는 단계를 포함한다. 상기 동적으로 발생된 객체는 시작 서버로부터 서빙될 때 캐싱 불가능한 것으로 식별된다.

다른 양태에서, 본 발명은 패킷 처리 타이머의 신호에 응답하여 캐싱된 동적으로 발생된 객체를 무효화하기 위한 장치에 관한 것이다. 상기 객체 무효화 장치는 적어도 하나의 동적으로 발생된 객체를 포함하는 네트워크 패킷들을 처리하고 상기 적어도 하나의 동적으로 발생된 객체를 캐시에 저장한다. 상기 객체 무효화 장치는 제1 신호를 발생하는 패킷 처리 타이머; 및 상기 패킷 처리 타이머와 통신하는 패킷 처리 엔진을 포함한다. 상기 패킷 처리 엔진은 상기 패킷 처리 타이머의 제1 신호의 수신에 응답하여 상기 네트워크 패킷을 처리한다. 상기 장치는 또한 상기 패킷 처리 엔진과 통신하고, 기억 소자에 캐싱된 동적으로 발생된 객체를 가진 캐시를 포함한다. 상기 캐시는 상기 캐싱된 동적으로 발생된 객체가 무효임을 나타내는 제2 신호를 상기 패킷 처리 엔진으로부터 수신한다. 일 실시예에서, 상기 제2 신호는 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 무효화 명령을 포함한다. 다른 실시예에서, 상기 제2 신호는 상기 캐싱된 동적으로 발생된 객체의 만기의 만료를 포함한다.

본 발명의 장치의 일 실시예에서, 상기 패킷 처리 엔진은 상기 패킷 처리 엔진에 의한 상기 네트워크 패킷의 처리 동안에 상기 제2 신호를 상기 캐시에 전송한다. 다른 실시예에서, 상기 패킷 처리 엔진은 상기 네트워크 패킷의 처리 완료시 상기 제2 신호를 상기 캐시에 전송한다. 일부 실시예들에서, 상기 패킷 처리 타이머는 1 밀리초 이상의 시간 간격으로 동작한다. 일 실시예에서, 상기 패킷 처리 타이머는 10 밀리초와 동일하거나 짧은 제1 시간 간격으로 캐싱된 객체를 무효화하기 위해 상기 제2 신호를 상기 캐시에 대해 트리거하는 시간 간격으로 동작한다.

본 발명의 장치는 1) 브리지, 2) 라우터, 3) 스위치, 및 4) SSL VPN 장치 중 어느 것을 포함할 수 있다. 상기 캐시, 상기 패킷 처리 엔진, 또는 상기 패킷 처리 타이머 중 하나는 상기 장치의 커널 공간에서 동작할 수 있다. 일부 실시예들에서, 상기 패킷 처리 타이머는 시작 서버로부터의 상기 동적으로 발생된 객체를 동적으로 발생하고 서빙하는 시간 기간보다 짧거나 같은 상기 캐싱된 동적으로 발생된 객체의 만기 시간 간격을 제공한다. 상기 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않는다. 시작 서버는 동적으로 발생된 객체를 포함하는 상기 네트워크 패킷을 전송할 수 있다.

다른 양태에서, 본 발명은 다수의 클라이언트로부터의 객체,예컨대 동적으로 발생된 객체에 대한 요청들에 응답하기 위해 플래시 캐싱이라고 하는 기술을 제공하기 위한 방법 및 시스템에 관한 것이다. 본 발명의 이 기술은, 예컨대 클라이언트로부터의 요청에 응답하여 클라이언트로의 전송을 위해, 그리고 객체가 버퍼에 저장되어 있는 동안 다른 클라이언트로부터의 동적으로 발생된 객체에 대한 추가적인 요청에 응답하기 위해, 버퍼에 저장된 동적으로 발생된 객체를 이용한다. 이 기술을 이용하여, 본 발명은 캐싱가능하지 않은 매우 빠르게 변화하는 객체들, 예컨대 동적으로 발생된 객체들에 대한 캐시 히트 레이트를 증가시킬 수 있다.

일 양태에서,본 발명은 복수의 클라이언트로부터 동적으로 발생된 객체에 대한 요청에 응답하는 방법에 관한 것이다. 상기 방법은 장치가 동적으로 발생된 객체에 대한 제1 클라이언트의 제1 요청에 대한 응답을 시작 서버로부터 수신하는 단계를 포함한다. 상기 응답은 상기 동적으로 발생된 객체를 포함한다. 상기 방법은 또한 상기 장치가 패킷 처리 엔진에 상기 응답을 제1 클라이언트에 전송할 것을 요청하는 단계를 포함한다. 상기 응답은 전송 대기하면서 버퍼에 홀딩된다. 상기 방법은 또한 상기 제1 클라이언트로의 상기 응답의 전송 완료 전에 상기 장치가 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하는 단계; 및 상기 장치가 상기 버퍼에 홀딩된 상기 제1 클라이언트에 대한 응답의 동적으로 발생된 객체를 상기 제2 클라이언트에 전송할 것을 상기 패킷 처리 엔진에 요청하는 단계를 포함한다.

본 발명의 일 실시예에서, 상기 방법은 상기 패킷 처리 엔진이 상기 응답을 상기 제1 클라이언트에 전송하는 단계를 포함한다. 다른 실시예에서, 상기 패킷 처리 엔진은 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제2 클라이언트에 전송하는 단계를 포함한다. 일부 실시예들에서, 상기 방법은 상기 패킷 처리 엔진이 상기 제1 클라이언트 또는 제2 클라이언트 중 하나에 상기 응답을 전송한 후 상기 버퍼로부터 상기 응답을 제거하는 단계를 포함한다. 일부 실시예들에서, 본 발명에 의해 사용된 버퍼는 TCP/IP 버퍼 또는 상기 장치의 TCP/IP 스택의 일부를 포함한다. 상기 장치는 상기 제1 클라이언트 및 제2 클라이언트로 전송하기 위한 단일 TCP/IP 스택을 가질 수 있고, 상기 버퍼는 상기 단일 TCP/IP 스택과 연관된다.

본 발명의 일부 실시예들에서, 상기 방법은 상기 장치가 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하고, 상기 장치가 상기 버퍼에 홀딩된 제1 클라이언트에 대한 응답의 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송할 것을 요청하는 단계를 포함한다. 일 실시예에서, 상기 패킷 처리 엔진이 상기 제1 클라이언트의 네트워크에의 접속에 관련된 하나 이상의 특징에 기초하여 상기 제1 클라이언트에 대한 응답을 홀딩한다. 다른 일 실시예에서, 상기 장치가 상기 제2 요청을 시작 서버로 전송하지 않고 큐잉한다. 일 실시예에서, 상기 장치는 상기 버퍼에 홀딩된 제1 요청의 응답을 이용하여 제2 요청에 응답한다.

일부 실시예들에서, 본 발명의 방법은 상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 제2 클라이언트에 전송한 후 상기 동적으로 발생된 객체를 상기 버퍼로부터 제거한다. 일 실시예에서, 상기 동적으로 발생된 객체는, 예컨대 시작 서버로부터 서빙될 때, 캐싱 불가능으로 식별된다. 본 발명의 다른 실시예들에서, 상기 장치는, 상기 제2 요청이 상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 단계를 포함한다.

일부 실시예들에서, 상기 장치는 상기 제1 클라이언트와 상기 시작 서버 간의 통신시 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치일 수 있다. 다른 실시예에서, 상기 장치는 상기 패킷 처리 엔진과 통신하는 캐시를 포함한다. 일 실시예에서, 상기 방법은 상기 캐시가 상기 제1 클라이언트에 대한 응답 또는 상기 제1 클라이언트의 동적으로 발생된 객체 중 하나를 상기 제2 클라이언트로 전송할 것을 상기 패킷 처리 엔진에 요청하는 단계를 포함한다.

다른 양태에서,본 발명은 복수의 클라이언트로부터 동적으로 발생된 객체에 대한 요청에 응답하는 시스템에 관한 것이다. 상기 시스템은 동적으로 발생된 객체에 대한 제1 클라이언트의 제1 요청에 대한 응답을 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 장치; 및 상기 장치로부터 전송 대기 중인 하나 이상의 네트워크 패킷을 홀딩하는 버퍼를 포함한다. 상기 시스템은 상기 응답을 제1 클라이언트에 전송하라는 요청을 상기 장치로부터 수신하는 패킷 처리 엔진을 포함하고, 상기 버퍼는 상기 응답을 포함하는 하나 이상의 네트워크 패킷을 홀딩한다. 상기 장치는 상기 제1 클라이언트로의 상기 응답의 전송 완료 전에 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하고, 상기 버퍼에 홀딩된 상기 제1 클라이언트에 대한 응답의 동적으로 발생된 객체를 상기 제2 클라이언트에 전송할 것을 상기 패킷 처리 엔진에 요청한다.

본 발명의 시스템의 일 실시예에서,상기 패킷 처리 엔진은 상기 응답을 상기 제1 클라이언트에 전송한다. 다른 실시예에서, 상기 패킷 처리 엔진은 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 상기 버퍼로부터 상기 제2 클라이언트로 전송한다. 상기 시스템의 일부 실시예들에서, 상기 패킷 처리 엔진은 상기 제1 클라이언트 또는 제2 클라이언트 중 하나에 상기 응답을 전송한 후 상기 버퍼로부터 상기 응답을 제거한다. 또한, 다른 실시예에서, 상기 버퍼는 TCP/IP 버퍼 또는 상기 장치의 TCP/IP 스택의 일부이다. 일부 실시예들에서, 상기 장치는 상기 제1 클라이언트 및 제2 클라이언트로 전송하기 위한 단일 TCP/IP 스택을 포함하고, 상기 버퍼는 상기 단일 TCP/IP 스택과 연관된다.

본 발명의 다른 실시예에서, 상기 장치는 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하고, 상기 장치는 상기 버퍼에 홀딩된 제1 클라이언트에 대한 응답의 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송할 것을 상기 패킷 처리 엔진에 요청한다. 일 실시예에서, 상기 패킷 처리 엔진은 상기 제1 클라이언트의 네트워크에의 접속에 관련된 하나 이상의 특징에 기초하여 상기 제1 클라이언트에 대한 응답을 홀딩한다. 다른 실시예에서, 상기 장치는 상기 제2 요청을 시작 서버에 전송하는 대신에 제2 요청을 큐잉한다. 일부 실시예들에서, 상기 패킷 처리 엔진은 상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 제2 클라이언트에 전송한 후 상기 동적으로 발생된 객체를 상기 버퍼로부터 제거한다. 일 실시예에서, 상기 동적으로 발생된 객체는 예컨대 시작 서버에 의해 캐싱 불가능으로 식별된다.

본 발명의 다른 실시예에서, 상기 장치는, 상기 제2 요청이 상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하다. 일부 실시예들에서, 상기 장치는 상기 제1 클라이언트와 상기 시작 서버 간의 통신시 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치이다. 상기 장치는 또한 상기 패킷 처리 엔진과 통신하는 캐시를 가질 수 있다. 또한, 상기 캐시는 상기 제1 클라이언트에 대한 응답 또는 상기 제1 클라이언트의 동적으로 발생된 객체 중 하나를 상기 제2 클라이언트로 전송할 것을 상기 패킷 처리 엔진에 요청할 수 있다.

다른 양태에서, 본 발명은 서버가 처리하고 있는 시간 동안 동일한 객체에 대해 추가적인 요청, 예컨대, 거의 동시적인 요청을 캐시가 수신하는 상황을 처리하고,제1 요청자에 대한 응답을 전송하기 위한 "플래시 크라우드(flash crowd)" 기술에 관한 것이다. 일단 거의 동시적인 요청들이 모두 캐시에 의해 응답되면, 객체는 추가적인 만료 시간 또는 필요한 무효화 행위 없이 캐시로부터 플러싱된다. 본 발명의 이 기술은 데이터가 캐싱 불가능으로 고려된 객체들에 대한 매우 짧은 시간 동안 캐싱 되어 서빙되는 것을 가능하게 한다. 이 접근법은 빠르게 변화하는 데이터, 예컨대, 실시간주식 시세, 또는 빠르게 진행되는 뉴스 스토리를 많은 동시 사용자들에 서빙하는 애플리케이션들을 크게 향상시킨다

일 양태에서, 본 발명은 네트워크 장치에서 복수의 클라이언트로부터의 동적으로 발생된 객체에 대한 요청에 응답하는 방법에 관한 것이다. 상기 방법은 시작 서버로부터의 제1 동적으로 발생된 객체에 대한 요청을 제1 클라이언트로부터 수신하고 상기 제1 요청을 상기 시작 서버에 전송하는 단계를 포함한다. 제1 클라이언트의 제1 요청에 응답하기 전에, 상기 방법은 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하는 단계를 포함한다. 또한 상기 방법은 제1 요청에 대한 응답을 상기 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 단계; 및 상기 제1 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제1 클라이언트에 전송하고, 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 제2 클라이언트에 전송하는 단계를 포함한다.

본 발명의 일 실시예에서, 상기 방법은 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하는 단계, 및 각 클라이언트의 요청에 응답하여 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송하는 단계를 포함한다. 일부 실시예들에서, 상기 방법은 상기 동적으로 발생된 객체를 상기 제2 클라이언트에 전송 완료하기 전에 상기 동적으로 발생된 객체에 대한 제3 요청을 제3 클라이언트로부터 수신하는 단계; 및 상기 제3 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제3 클라이언트에 전송하는 단계를 포함한다.

다른 실시예에서, 본 발명의 방법은 상기 제1 요청 및 상기 제2 요청을 거의 동시에 수신한다. 일 실시예에서, 상기 제2 요청을 시작 서버로 전송하지 않고 큐잉한다. 일부 실시예들에서 상기 방법은 상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 상기 제2 클라이언트에 전송한 후에 상기 동적으로 발생된 객체를 캐시로부터 플러싱한다. 일 실시예에서, 상기 동적으로 발생된 객체는 예컨대 시작 서버로부터 서빙될 때 캐싱 불가능으로 식별된다. 상기 방법은 상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제2 요청은 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 단계를 포함할 수 있다. 또 다른 실시예에서, 상기 방법은 엔티티 태그 헤더 또는 캐시-제어 헤더를 포함하도록 상기 응답을 수정하고, 상기 수정된 응답을 상기 제1 클라이언트 또는 상기 제2 클라이언트에 전송한다.

다른 양태에서, 본 발명은 복수의 클라이언트로부터 동적으로 발생된 객체에 대한 요청에 응답하는 네트워크 장치에 관한 것이다. 네트워크 장치는 시작 서버로부터의 제1 동적으로 발생된 객체에 대한 요청을 제1 클라이언트로부터 수신하는 수단; 상기 제1 요청을 상기 시작 서버에 전송하는 수단; 제1 클라이언트의 제1 요청에 응답하기 전에 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하는 수단; 제1 요청에 대한 응답을 상기 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 수단; 및 상기 제1 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제1 클라이언트에 전송하고, 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 제2 클라이언트에 전송하는 수단을 포함한다.

본 발명의 일 실시예에서, 네트워크 장치는 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하고, 각 클라이언트의 요청에 응답하여 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송하는 수단을 더 포함한다. 다른 실시예에서, 네트워크 장치는 상기 동적으로 발생된 객체를 상기 제2 클라이언트에 전송 완료하기 전에 상기 동적으로 발생된 객체에 대한 제3 요청을 제3 클라이언트로부터 수신하는 수단; 및 상기 제3 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제3 클라이언트에 전송하는 수단을 포함한다. 다른 실시예들에서, 네트워크 장치는 상기 제1 요청 및 상기 제2 요청을 거의 동시에 수신하는 수단을 포함한다. 일부 실시예들에서, 상기 네트워크 장치는 제2 요청을 서버로 전송하지 않고 제2 요청을 큐잉한다.

일 실시예에서, 본 발명의 네트워크 장치는 상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 상기 제2 클라이언트에 전송한 후에 상기 동적으로 발생된 객체를 캐시로부터 플러싱한다. 일부 실시예들에서, 상기 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않는다. 다른 실시예들에서, 네트워크 장치는 상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제2 요청은 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 수단을 포함한다. 다른 실시예들에서,네트워크 장치는 엔티티 태그 헤더 또는 캐시-제어 헤더 중 하나를 포함하도록 상기 응답을 수정하고, 상기 수정된 응답을 상기 제1 클라이언트 또는 상기 제2 클라이언트 중 하나에 전송하는 수단을 또한 포함한다. 네트워크 장치는 상기 클라이언트와 상기 시작 서버 간의 통신시 어플라이언스 또는 컴퓨팅 장치일 수 있다.

또 다른 양태에서, 본 발명은 상기 응답에서 클라이언트에 대해 동적으로 발생된 객체를 캐싱 가능으로 식별하기 위해, 동적으로 발생된 객체를 캐싱 가능으로 식별하지 않은 서버로부터의 응답을 상기 캐시가 수정하는 방법 및 시스템에 관한 것이다. 일부 실시예들에서, 예컨대 객체들에 대한 HTTP 요청 및 응답을 처리하는 실시예에서, 본 발명의 기술들은 시작 서버로부터 엔티티 태그 및/또는 캐시 제어 정보없이 제공된 객체들에 대한 캐시 제어를 제공하기 위해 상기 응답에 엔티티 태그 또는 "이태그"를 삽입한다. 본 발명의 이 기술은 캐시가 후속 요청에서 히트를 체크하는 것을 가능하게 하기 위해 정보, 예컨대 객체에 대한 엔티티 태그 및 캐시 제어 정보를 클라이언트에 대한 응답에 삽입함으로써 캐시 히트 레이트를 증가시킨다.

일 양태에서, 본 발명은 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐싱하기 위한 엔티티 태그 이용 방법에 관한 것이다. 이 방법은 캐시가 동적으로 발생된 객체에 대한 클라이언트의 요청에 대한 응답을 시작 서버로부터 수신하되, 상기 동적으로 발생된 객체는 캐싱 불가능한 것으로 식별된 단계; 상기 캐시가 상기 캐시에 저장된 상기 동적으로 발생된 객체에 대한 엔티티 태그를 발생하는 단계; 상기 캐시가 상기 발생된 엔티티 태그를 포함하도록 상기 응답을 수정하는 단계; 및 상기 캐시가 상기 동적으로 발생된 객체를 캐싱 가능으로 식별하는 상기 수정된 응답을 상기 클라이언트에 전송하는 단계를 포함한다.

본 발명의 일 실시예에서, 상기 시작 서버로부터 수신된 상기 응답은 엔티티 태그를 포함하지 않는다. 일부 실시예들에서, 상기 캐시는 상기 동적으로 발생된 객체를 캐싱하기 위해 상기 클라이언트에 대한 지속 기간을 식별하도록 상기 응답을 수정한다. 다른 실시예들에서, 상기 동적으로 발생된 객체가 상기 캐시 또는 상기 시작 서버 중 하나에 의해 변경되었는지를 체크한 후, 상기 캐시가 상기 응답을 저장하고 상기 응답을 서빙할 것을 상기 클라이언트에 지시하기 위해 상기 응답을 수정한다. 일 실시예에서, 상기 시작 서버로부터의 응답은 상기 동적으로 발생된 객체에 대한 캐시 제어 정보를 갖고 있지 않고, 상기 캐시는 캐시 제어 정보를 포함하도록 상기 클라이언트에 전송된 응답을 수정한다.

일부 실시예들에서, 본 발명의 방법은 상기 캐시에 의해 상기 엔티티 태그에 대한 번호를 발생하는 단계를 더 포함한다. 상기 캐시는 상기 발생된 엔티티 태그를 상기 동적으로 발생된 객체와 함께 저장할 수 있다. 다른 실시예에서, 상기 캐시는 캐시 제어 정보를 상기 동적으로 발생된 객체와 함께 저장할 수 있다. 일 실시예에서, 상기 캐시는 상기 캐싱된 동적으로 발생된 객체를 상기 발생된 엔티티 태그 및 캐시 제어 정보와 함께 서빙한다.

본 발명의 일부 실시예들에서, 상기 캐시는 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 중 하나 상에서 동작된다. 다른 실시예에서, 상기 요청 또는 상기 응답은 HTML(HyperText Markup Language)를 포함한다. 다른 실시예에서, 상기 캐시는 상기 발생된 엔티티 태그를 식별하는 이태그 헤더를 포함하도록 상기 응답을 수정하고, 또 다른 실시예에서 상기 캐시는 캐시-제어 헤더를 포함하도록 상기 응답을 수정한다. 일부 실시예들에서, 상기 방법은 상기 캐시가 상기 클라이언트로부터 If-None-Match 헤더를 가진 제2 요청을 수신하는 단계; 및 제2 요청에 응답하여, 상기 If-None-Match 헤더와 연관된 상기 이태그 값을, 상기 동적으로 발생된 객체와 함께 상기 캐시에 저장된 상기 엔티티 태그와 비교하는 단계를 포함한다. 하나의 다른 실시예에서, 상기 이태그 값은 상기 엔티티 태그와 일치하면, 상기 캐시가 상기 제2 요청에 대한 수정되지 않은 응답을 상기 클라이언트에 전송하고, 다른 실시예에서, 상기 이태그 값이 상기 엔티티 태그와 일치하지 않으면, 상기 캐시가 갱신된 동적으로 발생된 객체를 제2 엔티티 태그와 함께 상기 클라이언트에 전송한다.

본 발명의 각종 실시예들을 첨부 도면을 참조하여 상세하게 설명한다.

여기에 포함되고 본 명세서의 일부를 형성하는 첨부 도면은 본 발명을 예시하며, 상세한 설명과 함께, 본 발명의 원리를 설명하고 당업자가 본 발명을 만들고 이용할 수 있도록 한다.

도 1은 본 발명의 실시예를 구현할 수 있는 네트워크 환경의 예를 예시한 블록도.

도 2는 본 발명의 일 실시예에 따라 통합 캐싱을 수행하는 어플라이언스의 예시적인 구조를 나타낸 블록도.

도 3A는 패킷 처리에 대한 장치 동작과 패킷 처리 타이머를 통합하기 위한 본 발명의 방법의 실시예에서 취해진 단계들의 흐름도.

도 3B는 도 3A에서 무효화 그래뉼래러티(granularity) 기술들을 실시하기 위한 본 발명의 방법의 실시예에서 행해지는 단계들의 흐름도.

도 4A는 진부한 객체들을 무효화하기 위해 무효화 명령을 이용하는 본 발명의 방법의 실시예에서 행해지는 단계들의 블록도.

도 4B는 객체 그룹의 무효화를 포함하는 본 발명의 방법의 실시예에서 행해지는 단계들의 블록도.

도 4C는 클라이언트 요청가 객체 결정인자들에 대해 분석되는 본 발명의 방법의 실시예에서 행해지는 단계들의 블록도.

도 4D는 객체 결정인자들을 이용하여 객체 그룹의 무효화를 포함하는 본 발명의 방법의 실시예에서 행해지는 단계들의 블록도.

도 5는 플래시 캐시 기술을 제공하는 본 발명의 방법의 실시예에서 행해지는 위한 단계들의 블록도.

도 6은 플래시 크라우드 제어 기술을 제공하기 위한 본 발명의 방법의 실시예에서 행해지는 단계들의 블록도.

도 7A 및 도 7B는 객체에 대한 엔티티 태그 및 캐시 제어를 제공하기 위한 본 발명의 방법의 실시예에서 행해지는 단계들의 흐름도.

도 8A 및 도 8B는 본 발명의 실시예를 실시하기 위한 컴퓨팅 장치의 실시예들의 블록도.

본 발명의 특징 및 이점은 동일한 참조 부호가 대응하는 요소들을 나타내는 도면을 참조하여 후술되는 발명의 상세한 설명으로부터 명백해진다. 도면에서, 동일한 참조 부호는 일반적으로 동일한, 기능적으로 유사한, 및/또는 구조적으로 유사한 요소를 나타낸다.

A. 네트워크 환경예

도 1은 본 발명의 실시예를 실시할 수 있는 네트워크 환경(100)의 예를 나타낸다. 도 1에 도시된 바와 같이, 예시적인 네트워크 환경(100)은 복수의 클라이언트(102a-102n); 복수의 서버(106a-106n); 및 캐시 어플라이언스, 장치, 또는 캐 시라고도 할 수 있는 어플라이언스(104)를 포함한다. 서버(106a-106n)는 요청된 콘텐트를 클라이언트(102a-102n)에 제공하는 객체 또는 관계형 데이터베이스들과 같은 데이터베이스들을 구성하고 관리한다. 이 이유 때문에, 서버(106a-106n)는 일반적으로, 반드시 그런 것은 아니지만, 요청된 콘텐트를 형성하는 객체들을 구성하므로 여기서는 "시작 서버들"라고도 한다. 클라이언트(102a-102n) 및 서버(106a-106n)의 각각은 임의 타입 및 형태의 컴퓨팅 장치, 예컨대 도 8A 및 도 8B를 참조하여 나중에 보다 상세히 설명되는 컴퓨팅 장치(800)일 수 있다. 예컨대, 클라이언트(102a-102n)는 통신 장치, 예컨대, 휴대 전화기 또는 개인 휴대 장치, 또는 임의 타입의 데스크톱 컴퓨터 외에 랩톱 또는 노트북 컴퓨터와 같은 모바일 컴퓨팅 장치일 수 있다.

클라이언트(102a-102n)의 각각은 공용 데이터 통신 네트워크(108)를 통해 어플라이언스(104)에 통신 가능하게 연결되고, 어플라이언스(104)는 전용 데이터 통신 네트워크(110)를 통해 서버(106a-106n)에 통신 가능하게 연결된다. 일 실시예에서, 공용 데이터 통신 네트워크(108)는 인터넷을 구비하고, 전용 데이터 통신 네트워크(110)는 기업 네트워크를 구비한다. 공용 데이터 통신 네트워크(108) 및 전용 데이터 통신 네트워크(110)는 네트워크, 공용, 전용 등의 타입 및 형태일 수 있고, 일부 경우에는 동일한 네트워크일 수 있다.

도 1은 클라이언트(102a-102n)와 서버(106a-106n) 사이의 네트워크(108) 및 네트워크(111)를 도시하고 있지만, 클라이언트(102a-102n) 및 서버(106a-106n)는 동일한 네트워크(108 또는 110) 상에 있을 수 있다. 네트워크(108, 110)는 동일한 타입의 네트워크 또는 상이한 타입의 네트워크일 수 있다. 네트워크(108) 및/또는 네트워크(110)는 회사 인트라넷, MAN(metropolitan area network)와 같은 LAN(local-area network), 또는 인터넷 또는 월드 와이드 웹과 같은 WAN(와이드 area network)일 수 있다. 네트워크(108 및/또는 110)는 임의 타입 및/또는 형태의 네트워크일 수 있고, 점대점(point to point) 네트워크, 브로드캐스트 네트워크, WAN, LAN, 통신 네트워크, 데이터 통신 네트워크, 컴퓨터 네트워크, ATM(Asynchronous Transfer Mode) 네트워크, SONET(Synchronous Optical Network) 네트워크, SDH(Synchronous Digital Hierarchy) 네트워크, 무선 네트워크, 및 유선 네트워크 중 어느 것을 포함할 수 있다. 네트워크(108 및/또는 110)의 토폴로지는 버스, 스타(star), 또는 링 네트워크 토폴로지일 수 있다. 네트워크(108 및/또는 110) 및 네트워크 토폴로지는 여기서 설명되는 본 발명의 동작을 지원할 수 있는 기술 분야의 당업자에게 잘 알려진 바와 같은 네트워크 또는 네트워크 토폴로지일 수 있다.

도 1에 도시된 바와 같이, 어플라이언스(104)는 공용 데이터 통신 네트워크(108) 및 전용 데이터 통신 네트워크(110) 상에 도시되어 있다. 일부 다른 실시예들에서, 어플라이언스(104)는 공용 데이터 통신 네트워크(108) 또는 전용 데이터 통신 네트워크(110) 상에 위치될 수 있다. 다른 실시예들에서, 어플라이언스(104)는 어떤 클라이언트(102a-102n)와 동일한 또는 상이한 네트워크(108, 110) 상의 개별 클라이언트(102a-102n) 또는 개별 서버(106a-106n)의 일체부일 수 있다. 이와 같이, 어플라이언스(104)는 클라이언트(102a-102n)와 서버(106a-106n) 사이의 네트 워크 또는 네트워크 통신 경로의 임의 지점에 있을 수 있다.

본 발명의 일 실시예에 따라, 어플라이언스(104)는 캐시 관리 로직을 포함하고, 캐시 메모리를 구현하는데 이용할 수 있는 기억 매체를 포함하거나 액세스한다. 이들 특징을 이용하여, 어플라이언스(104)는 서버(106a-106n) 중 어느 서버에 클라이언트(102a-102n)가 행한 객체 요청을 감시한다. 이들 객체 요청에 응답하여 서버(106a-106n)로부터 수신된 객체들은 어플라이언스(104)에 의해 캐시 메모리에 저장된 에 저장된다. 클라이언트(102a-102n) 중 어느 클라이언트로부터의 동일한 객체에 대한 후속 요청은 서버(106a-106n)에 요청을 전달하기보다는 캐시로부터 객체를 전달하려고 하는 어플라이언스(104)에 의해 인터셉트된다. 이는 클라이언트(102a-102n)로부터의 요청에 응답하는데 필요한 시간과 인프라구조 지원 서버(106a-106n) 상의 부하를 감소시키는 이중 혜택을 제공한다.

정리하면, 도 1에 도시된 네트워크 환경(100)은 단지 예시를 위해 제공되며 한정을 의도한 것이 아니다. 여기서 제공된 내용에 기초하여, 당업자는 본 발명은 객체 요청 및 응답이 하나 이상의 네트워크(들)의 노드들 상에서 전송되는 네트워크 환경에서 구현될 수 있음을 쉽게 이해할 것이다.

B. 어플라이언스 또는 장치 구조의 예

여기서 보다 상세히 설명되는 바와 같이, 본 발명의 실시예에서, 어플라이언스(104)는 운영체제의 커널 레벨에서의 캐싱 기능을, 암호 해독, 압축 해제, 또는 인증 및/또는 허가를 포함하나 이에 한정되지 않는 하나 이상의 다른 처리 작업들 과 통합한다. 이러한 구현은 2005년 6월 29일에 출원되고 발명의 명칭이 "데이터 통신 네트워크에서 통합 캐싱을 수행하는 방법 및 장치"인, 공동 소유이고 함께 계류중인 미국 특허 출원 제11/169,002호에 예시되어 있고, 이 특허 출원은 여기서 참고 문헌으로서 포함된다. 이러한 예시적인 구조는 도 2에 따라 여기서 설명되나, 본 발명은 이에 한정되지 않고 여기서 설명되는 본 발명의 동작을 실시하는데 다른 구조들이 사용될 수 있다.

도 2는 어플라이언스(104)의 구조(200)의 예를 나타낸다. 위에서 언급된 바와 같이, 구조(200)는 단지 예로서 제공되는 것으로 한정을 의도하지 않는다. 도 2에 도시된 바와 같이, 예시적인 구조(200)는 하드웨어 계층(206), 및 사용자 공간(202) 및 커널 공간(204)으로 분리된 소프트웨어 계층으로 구성된다.

하드웨어 계층(206)은 커널 공간(204) 내의 프로그램들 및 서비스들 및 사용자 공간(202)이 실행되는 하드웨어 소자들을 제공한다. 하드웨어 계층(206)은 또한 커널 공간(204) 및 사용자 공간(202) 내의 프로그램들 및 서비스들이 어플라이언스(104)에 대해 데이터를 내부적으로 그리고 외부적으로 전달하는 것을 가능하게 하는 구조들 및 소자들을 제공한다. 도 2에 도시된 바와 같이, 하드웨어 계층(206)은 소프트웨어 프로그램들 및 서비스들을 실행하기 우한 처리 유닛(262)을, 소프트웨어 및 데이터를 저장하기 위한 메모리(264), 네트워크를 통해 데이터를 송수신하기 위한 네트워크 포트들(266), 및 네트워크를 통해 송수신되는 데이터의 Secure Sockets 계층 처리에 관련된 기능을 수행하기 위한 암호화 프로세서(260)를 포함한다. 일부 실시예들에서, 중앙 처리 장치(262)는 단일 프로세서에서 암호화 프로세서(260)의 기능들을 수행할 수 있다. 또한, 하드웨어 계층(206)은 처리 유닛(262) 및 암호화 프로세서(260)용 다중 프로세서를 구비할 수 있다. 어플라이언스(104)의 하드웨어 계층(206)은 일반적으로 암호화 프로세서(260)와 함께 예시되어 있으나, 프로세서(260)는 암호화 프로토콜, 예컨대 SSL(Secure Socket Layer) 또는 TLS(Transport Layer Security) 프로토콜에 관련된 기능을 수행하기 위한 프로세서일 수 있다. 일부 실시예들에서, 프로세서(260)는 범용 프로세서(GPP)일 수 있고, 다른 실시예들에서는, 보안 관련 프로토콜의 처리를 수행하는 실행가능 명령들을 가질 수도 있다.

어플라이언스(104)의 하드웨어 계층(206)이 도 2에서는 일정한 소자들로 예시되어 있으나, 어플라이언스(104)의 하드웨어 부분들 또는 구성 요소들은 컴퓨팅 장치, 예컨대 여기서 도 8A 및 도 8B를 참조하여 예시 및 설명되는 컴퓨팅 장치(800)의 임의 타입 및 형태의 소자들, 하드웨어 또는 소프트웨어를 구비할 수 있다. 일부 실시예들에서, 어플라이언스(104)는 서버, 게이트웨이, 라우터, 스위치, 브리지 또는 다른 타입의 컴퓨팅 또는 네트워크 장치를 구비할 수 있고, 연관된 하드웨어 및/또는 소프트웨어 소자들을 가질 수 있다.

어플라이언스(104)의 운영체제는 이용 가능 시스템 메모리를 커널 공간(204) 및 사용자 공간(204)에 할당, 관리, 또는 분리시킨다. 소프트웨어 구조(200)의 예에서, 운영체제는 임의 타입 및/또는 형태의 유닛스(Unix) 운영체제일 수 있으며 본 발명은 이에 한정되지 않는다. 이와 같이, 어플라이언스(104)는 운영체제, 예컨대 마이크로소프트 윈도우즈 운영체제, 상이한 유닉스(Unix) 및 리눅스(Linux) 운영체제, 매킨토시(Macintosh) 컴퓨터용 임의 버전의 Mac OS, 임베디드 운영체제, 네트워크 운영체제, 실시간 운영체제, 오픈 소스 운영체제, 독점 운영체제, 모바일 컴퓨팅 장치 또는 네트워크 장치용 운영체제, 또는 어플라이언스(104) 상에서 구동될 수 있고 여기서 설명하는 동작들을 수행할 수 있는 어떤 다른 운영체제를 구동할 수 있다.

커널 공간(204)은 장치 드라이버, 커널 확장 또는 다른 커널 관련 소프트웨어를 포함해서 커널(230)을 구동하기 위해 예약된다. 당업자에게 잘 알려진 바와 같이, 커널(230)은 운영체제의 핵심이며, 애플리케이션(104)의 자원 및 하드웨어-관련 소자들의 액세스, 제어, 및 관리를 제공한다. 본 발명의 일 실시예에 따라, 커널 공간(204)은 또한 캐시 관리자(232)와 함께 작업하는 다수의 네트워크 서비스들 또는 프로세스들을 포함한다. 때때로 통합 캐시라고도 하며, 그 이점은 여기서 상세히 후술된다. 또한, 커널(230)의 실시예는 장치(104)에 의해 설치, 구성 또는 사용되는 운영체제 실시예에 좌우될 것이다.

일 실시예에서, 장치(104)는 하나의 네트워크 스택(267), 예컨대 클라이언트(102a-102b) 및/또는 서버(106a-106n)와 통신하기 위한 TCP/IP 기반 스택을 구비한다. 일 실시예에서, 네트워크 스택(267)은 제1 네트워크, 예컨대 네트워크(108), 및 제2 네트워크(110)와 통신하는데 사용된다. 일부 실시예들에서, 장치(104)는 제1 전송 계층 접속, 예컨대 클라이언트(102a-102n)의 TCP 접속을 종료하고, 클라이언트(102a-102n)에 의한 사용을 위해 서버(106a-106n)에의 제2 전송 계층 접속을 설정하며, 예컨대, 제2 전송 계층 접속은 어플라이언스(104) 및 서 버(106a-106n)에서 종료된다. 제1 및 제2 전송 계층 접속은 단일 네트워크 스택(267)을 통해 설정될 수 있다. 다른 실시예들에서, 장치(104)는 다중 네트워크 스택(예컨대 267 및 267')을 구비할 수 있고, 및 제1 전송 계층 접속은 하나의 네트워크 스택(267)에서 설정 또는 종료될 수 있고, 제2 전송 계층 접속은 제2 네트워크 스택(267')에서 설정 또는 종료될 수 있다. 예컨대, 하나의 네트워크 스택은 제1 네트워크상에서 네트워크 패킷을 수신 및 전송하기 위한 것일 수 있고, 제2 네트워크상에서 네트워크 패킷들을 수신 및 전송하기 위한 다른 네트워크 스택일 수도 있다. 일 실시예에서, 네트워크 스택(267)은 어플라이언스(104)에 의한 전송을 위해 하나 이상의 네트워크 패킷들을 큐잉하기 위한 버퍼(243)를 구비한다.

도 2에 도시된 바와 같이, 커널 공간(204)은 캐시 관리자(232), 고속 계층 2-7 통합 패킷 엔진(240), 암호화 엔진(234), 정책 엔진(236) 및 멀티 프로토콜 압축 로직(238)을 포함한다. 사용자 공간(202) 대신에 널 공간(204) 또는 커널 모드에서의 이들 구성 요소 또는 프로세스들(232, 240, 234, 236, 238)의 구동은 이들 구성 요소 각각 및 그 조합의 성능을 향상시킨다. 커널 동작은 이들 구성 요소 또는 프로세스들(232, 240, 234, 236, 238)은 장치(104)의 운영체제의 핵심 주소 공간에서 구동됨을 의미한다. 예컨대, 커널 모드에서 암호화 엔진(234)의 구동은 암호화 및 암호 해독 동작을 커널로 이동시킴으로써 암호화 성능을 향상시키며, 이에 따라 커널 모드에서의 메모리 공간 또는 커널 쓰레드와 사용자 모드에서의 메모리 공간 또는 쓰레드 간의 전이 회수가 감소된다. 예컨대, 커널 모드에서 얻어진 데이터는 사용자 모드에서 구동되는 프로세스 또는 쓰레드로, 예컨대 커널 레벨 데이터 구조로부터 사용자 레벨 데이터 구조로 전달 또는 카피될 필요가 없을 수 있다. 다른 양태에서, 커널 모드와 사용자 모드 간의 콘텍스트 스위치들의 개수가 또한 감소된다. 또한, 구성 요소 또는 프로세스들(232, 240, 235, 236, 238)의 동기화 및 이들 간의 통신은 커널 공간(204)에서 보다 효율적으로 수행될 수 있다.

일부 실시예들에서, 구성 요소(232, 240, 234, 236, 238)의 어느 부분은 커널 공간(204)에서 구동 또는 동작할 수 있고, 이들 구성 요소(232, 240, 234, 236, 238)의 다른 부분은 사용자 공간(202)에서 구동 또는 동작할 수 있다. 일 실시예에서, 본 발명은 하나 이상의 네트워크 패킷들, 예컨대, 클라이언트로부터의 요청(102a-102n) 또는 서버(106a-106n)로부터 응답을 포함하는 네트워크 패킷의 부분에 대한 액세스를 제공하는 커널-레벨 데이터 구조를 이용한다. 일부 실시예들에서, 커널-레벨 데이터 구조는 전송 계층 드라이버 인터페이스 또는 필터를 통해 네트워크 스택(267)으로 패킷 엔진(240)에 의해 얻어질 수 있다. 커널-레벨 데이터 구조는 네트워크 스택(267), 네트워크 스택(267)에 의해 수신 또는 전송되는 네트워크 트래픽 또는 패킷들에 관련된 커널 공간(204)을 통해 엑세스 가능한 인터페이스 및/또는 데이터를 포함할 수 있다. 다른 실시예들에서, 커널-레벨 데이터 구조는 구성 요소 또는 프로세스의 원하는 동작을 수행하기 위해 구성 요소 또는 프로세스들(232, 240, 234, 236, 238)에 의해 사용될 수 있다. 일 실시예에서, 구성 요소(232, 240, 234, 236, 238)는 커널-레벨 데이터 구조를 사용할 때 커널 모드(204)에서 구동되고, 다른 실시예에서, 구성 요소(232, 240, 234, 236, 238)는 커널-레벨 데이터 구조를 사용할 때 사용자 모드에서 구동된다. 일부 실시예들에 서, 커널-레벨 데이터 구조는 제2 커널-레벨 데이터 구조 또는 원하는 사용자-레벨 데이터 구조로 카피 또는 전달될 수 있다.

캐시 관리자(232)는 임의 타입 및 형태의 콘텐트, 예컨대 시작 서버(106a-106n)에 의해 서빙되는 객체들 또는 동적으로 발생된 객체들의 캐시 액세스, 제어 및 관리를 제공하기 위해 소프트웨어, 하드웨어 또는 소프트웨어 및 하드웨어의 조합을 구비할 수 있다. 캐시 관리자(232)에 의해 처리 및 저장되는 데이터, 객체들 또는 콘텐트는 임의 포맷의 데이터, 예컨대 마크업(markup) 언어로 작성된 데이터를 포함할 수 있고, 임의 프로토콜을 통해 전송된다. 일부 실시예들에서, 캐시 관리자(232)는 다른 곳에 저장된 원래 데이터 또는 이전에 컴퓨팅, 발생 또는 전송된 데이터를 복제하며, 여기서, 원래 데이터가 캐시 메모리 소자를 판독하는 것에 비해 페치, 컴퓨터 또는 얻는데 보다 긴 액세스 시간을 필요로 할 수 있다. 일단 데이터가 캐시 메모리 소자에 저장되면, 원래 데이터를 다시 페치하거나 다시 컴퓨팅하지 않고 캐싱된 카피를 액세스함으로써 장래 사용이 행해질 수 있어, 액세스 시간이 감소된다. 일부 실시예들에서, 캐시 메모리 소자는 장치(104)의 메모리(264)에 데이터 객체를 구비한다. 다른 실시예들에서, 캐시 메모리 소자는 메모리(264)보다 빠른 액세스 시간을 가진 메모리를 구비할 수 있다. 다른 실시예에서, 캐시 메모리 소자는 장치(104)의 임의 타입 및 형태의 기억 소자, 예컨대 하드 디스크의 일부를 구비할 수 있다. 일부 실시예들에서, 처리 유닛(262)은 본 발명의 캐시 관리자(232)에 의해 사용되는 캐시 메모리를 제공할 수 있다. 또 다른 실시예들에서, 캐시 관리자(232)는 캐싱 데이터, 객체들, 및 다른 콘텐트용 메모리, 기억, 또 는 처리 유닛의 임의 부분 및 조합을 사용할 수 있다.

또한, 본 발명의 캐시 관리자(232)는 여기서 설명되는 본 발명의 기술들의 실시예들을 수행하기 위해 로직, 기능, 규칙, 또는 동작을 포함한다. 예컨대, 캐시 관리자(232)는 무효화 시간 기간의 만료에 기초하여 또는 클라이언트(102a-102n) 또는 서버(106a-106n)로부터의 무효화 명령의 수신시 객체들을 무효화시키는 로직 또는 기능을 포함한다. 일부 실시예들에서, 캐시 관리자(232)는 커널 공간(204)에서 그리고 다른 실시예들에서는 사용자 공간(202)에서 실행되는 프로그램, 서비스, 프로세스 또는 작업으로서 동작할 수 있다. 일 실시예에서, 캐시 관리자(232)의 제1 부분은 사용자 공간(202)에서 실행되고, 제2 부분은 커널 공간(204)에서 실행된다. 일부 실시예들에서, 캐시 관리자(232)는 임의 타입의 GPP(general purpose processor), 또는 어떤 다른 타입의 통합 회로, 예컨대 FPGA(Field Programmable Gate Array), PLD(Programmable Logic Device), 또는 ASIC(Application Specific Integrated Circuit)를 구비할 수 있다.

정책 엔진(236)은 예컨대, 지능형 통계 엔진 또는 다른 프로그래머블 애플리케이션(s)을 포함할 수 있다. 일 실시예에서, 정책 엔진(236)은 사용자가 캐싱 정책을 식별, 지정, 정의 또는 구성하는 것을 가능하게 하는 구성 메커니즘을 제공한다. 일부 실시예들에서, 정책 엔진(236)은 또한 사용자-선택된 캐싱 정책 판단을 가능하게 하기 위해 데이터 구조들, 예컨대 룩업 테이블 또는 해쉬 테이블을 지원하기 위해 메모리를 액세스한다. 다른 실시예들에서, 정책 엔진(236)은 액세스, 보안의 제어 및 관리, 네트워크 트래픽, 네트워크 액세스, 압축, 또는 어플라이언 스(104)에 의해 수행되는 어떤 다른 기능 또는 동작 이외에 어플라이언스(104)에 의해 캐싱 되는 객체들, 데이터 또는 콘텐트의 액세스, 제어 및 관리를 결정 및 제공하기 위한 로직, 규칙, 기능 또는 동작을 포함할 수 있다. 또한 특정 캐싱 정책들의 예들을 여기서 설명한다.

암호화 엔진(234)은 보안 관련 프로토콜, 예컨대 SSL 또는 TLS, 또는 관련 기능을 처리하기 위한 로직, 비즈니스 규칙, 기능 또는 동작을 구비한다. 예컨대, 암호화 엔진(234)은 어플라이언스(104)를 통해 전달되는 네트워크 패킷들, 또는 그 일부를 암호화 및 암호 해독한다. 암호화 엔진(234)은 클라이언트(102a-102n), 서버(106a-106n), 또는 어플라이언스(104)를 위해 SSL 또는 TLS 접속을 설정할 수도 있다. 이와 같이, 암호화 엔진(234)은 SSL 처리의 오프로딩(offloading) 및 가속(acceleration)을 제공한다. 일 실시예에서, 암호화 엔진(234)은 클라이언트(102a-102n)와 서버(106a-106n) 간의 가상 전용 네트워크를 제공하기 위해 터널링 프로토콜을 사용한다. 일부 실시예들에서, 암호화 엔진(234)은 암호화 프로세서(260)와 통신한다. 다른 실시예들에서, 암호화 엔진(234)은 암호화 프로세서(260) 상에서 구동되는 실행가능 명령들을 구비한다.

멀티프로토콜 압축 엔진(238)은 네트워크 패킷의 하나 이상의 프로토콜, 예컨대 장치(104)의 네트워크 스택(267)에 의해 사용되는 프로토콜을 압축하기 위한 로직, 비즈니스 규칙, 기능 또는 동작을 구비한다. 일 실시예에서, 멀티프로토콜 압축 엔진(238)은 MAPI(Messaging Application Programming Interface)(email), FTP(File Transfer Protocol), HTTP(Hyper텍스트 Transfer Protocol), CIFS(Common Internet File System) 프로토콜(파일 전송), ICA(Independent Computing Architecture) 프로토콜, RDP(Remote Desktop Protocol), WAP(Wireless Application Protocol), 모바일 IP 프로토콜, 및 VoIP(Voice Over IP) 프로토콜을 포함한 TCP/IP 기반 프로토콜을, 클라이언트(102a-102n)와 서버(106a-106n) 사이에서 양방향으로 압축한다. 다른 실시예들에서, 멀티프로토콜 압축 엔진(238)은 HTML(Hyper텍스트 Markup Language) 기반 프로토콜의 압축을 제공하고, 일부 실시예들에서 마크업 언어, 예컨대 XML(Extensible Markup Language)의 압축을 제공한다. 일 실시예에서, 멀티프로토콜 압축 엔진(238)은 고-성능 프로토콜, 예컨대 어플라이언스(104)-어플라이언스(104) 통신을 위해 설계된 프로토콜의 압축을 제공한다. 다른 실시예에서, 멀티프로토콜 압축 엔진(238)은 수정된 전송 제어 프로토콜, 예컨대 T/TCP(Transaction TCP), TCP-SACK(TCP with selection acknowledgements), TCP-LW(TCP with large windows), TCP-Vegas 프로토콜과 같은 폭주 예측 프로토콜, 및 TCP 스푸핑(spoofing) 프로토콜을 이용하여 통신의 페이로드 또는 통신을 압축한다.

이와 같이, 본 발명의 멀티프로토콜 압축 엔진(238)은 데스크톱 클라이언트, 예컨대, 마이크로소프트 아웃룩, 오라클, SAP 및 Siebel 같은 대중적인 기업 애플리케이션에 의한 클라이언트와 같은 비(non)-웹 씬 클라이언트, 및 포켓 PC와 같은 모바일 클라이언트를 통해 애플리케이션을 액세스하는 사용자들을 위해 성능을 가속화한다. 일부 실시예들에서, 커널 모드(204)에서 실행되고 네트워크 스택(267)을 액세스하는 패킷 처리 엔진(240)과 통합됨으로써 멀티프로토콜 압축 엔진(238)은 TCP/IP 프로토콜, 예컨대 애플리케이션 계층 프로토콜에 의해 운반되는 프로토콜을 압축할 수 있다.

일반적으로 패킷 처리 엔진 또는 패킷 엔진이라고도 하는 고속 계층 2-7 통합 패킷 엔진(240)은 네트워크 포트들(266)을 통해 어플라이언스(104)에 의해 수신 및 전송되는 패킷들의 커널-레벨 처리를 관리한다. 고속 계층 2-7 통합 패킷 엔진(240)은 예컨대 네트워크 패킷의 수신 또는 네트워크 팩킷의 전송을 위해 처리 동안에 하나 이상의 네트워크 패킷들을 큐잉하기 위한 버퍼를 구비할 수 있다. 또한, 고속 계층 2-7 통합 패킷 엔진(240)은 네트워크 포트들(266)을 통해 네트워크 패킷들을 송수신하기 위해 하나 이상의 네트워크 스택들(267)과 통신한다. 고속 계층 2-7 통합 패킷 엔진(240)은 암호화 엔진(234), 캐시 관리자(232), 정책 엔진(236) 및 멀티프로토콜 압축 로직(238)과 함께 작업한다. 특히, 암호화 엔진(234)은 패킷들의 SSL 처리를 수행하도록 구성되고, 정책 엔진(236)은 요청-레벨 콘텐트 스위칭 및 요청-레벨 캐시 리디렉션과 같은 트래픽 관리 관련 기능을 수행하도록 구성되고, 멀티프로토콜 압축 로직(238)은 데이터의 압축 및 압축 해제와 관련된 기능을 수행하도록 구성된다.

고속 계층 2-7 통합 패킷 엔진(240)은 패킷 처리 타이머(242)를 포함한다. 일 실시예에서, 패킷 처리 타이머(242)는 들어오거나, 즉, 수신되거나 나가는, 즉, 전송되는 네트워크 패킷들의 처리를 트리거하기 위해 하나 이상의 시간 간격을 제공한다. 일부 실시예들에서, 고속 계층 2-7 통합 패킷 엔진(240)은 타이머(242)에 응답하여 네트워크 패킷들을 처리한다. 패킷 처리 타이머(242)는 시간 관련 이벤 트, 간격 또는 발생을 통보, 트리거 또는 전달하기 위해 임의 타입 및 형태의 신호를 패킷 엔진(240)에 제공한다. 많은 실시예들에서, 패킷 처리 타이머(242)는 밀리초 정도, 예컨대 100ms, 50ms 또는 25ms 동작한다. 예컨대, 일부 실시예들에서, 패킷 처리 타이머(242)는 시간 간격을 제공하거나, 네트워크 패킷이 10 ms 시간 간격으로, 다른 실시예들에서는 5 ms 시간 간격으로, 또 다른 실시예들에서, 3, 2, 또는 1 ms만큼 짧은 시간 간격으로 고속 계층 2-7 통합 패킷 엔진(240)에 의해 처리되게 한다. 고속 계층 2-7 통합 패킷 엔진(240)은 동작 동안에 암호화 엔진(234), 캐시 관리자(232), 정책 엔진(236) 및 멀티프로토콜 압축 엔진(238)과 인터페이싱, 통합 또는 통신할 수 있다. 이와 같이, 암호화 엔진(234), 캐시 관리자(232), 정책 엔진(236) 및 멀티프로토콜 압축 로직(238)의 로직, 기능, 또는 동작은 패킷 처리 타이머(242) 및/또는 패킷 엔진(240)에 응답하여 수행될 수 있다. 그러므로, 암호화 엔진(234), 캐시 관리자(232), 정책 엔진(236) 및 멀티프로토콜 압축 로직(238)의 로직, 기능, 또는 동작은 패킷 처리 타이머(242)를 통해 제공되는 시간 간격의 그래뉼래러티로, 예컨대, 10ms 이하의 시간 간격으로 수행될 수 있다. 예컨대, 일 실시예에서, 캐시 관리자(232)는 고속 계층 2-7 통합 패킷 엔진(240) 및/또는 패킷 처리 타이머(242)에 응답하여 캐싱된 객체들의 무효화를 수행할 수 있다. 다른 실시예에서, 캐싱된 객체의 만료 또는 무효화 시간은 예컨대 10 ms 마다 패킷 처리 타이머(242)의 시간 간격과 동일한 그래뉼래러티로 설정될 수 있다.

커널 공간(204)과는 대조적으로, 사용자 공간(202)은 사용자 모드에서 구동 되는 사용자 모드 애플리케이션들 또는 프로그램들에 의해 사용되는 운영체제의 메모리 영역 또는 부분이다. 사용자 모드 애플리케이션은 액세스 커널 공간(204)을 직접 액세스할 수 없고 커널 서비스들을 액세스하기 위해 서비스 호를 이용한다. 도 2에 도시된 바와 같이, 어플라이언스(104)의 사용자 공간(202)은 그래픽 사용자 인터페이스(GUI)(210), 명령 라인 인터페이스(CLI)(212), 쉘 서비스들(214), 헬스 모니터링 프로그램(216), 및 대몬 서비스들(218)을 포함한다. GUI(210) 및 CLI(212)는 시스템 관리자 또는 다른 사용자가 예컨대 어플라이언스(104)의 운영체제를 통해 어플라이언스(104)와 상호 작용할 수 있고 어플라이언스(104)의 동작을 제어할 수 있는 수단을 제공하며, 사용자 공간(202) 또는 커널 공간(204)이 된다. GUI(210)는 임의 타입 및 형태의 그래픽 사용자 인터페이스일 수 있고, 임의 타입의 프로그램 또는 애플리케이션, 예컨대 브라우저에 의해 텍스트, 그래픽 등을 통해 제공될 수 있다. CLI(212)는 임의 타입 및 형태의 명령 라인 또는 텍스트-기반 인터페이스, 예컨대 운영체제에 의해 제공되는 명령라인일 수 있다. 예컨대, CLI(212)는 사용자들이 운영체제와 상호 작용하는 것을 가능하게 하는 도구인 쉘을 구비할 수도 있다. 일부 실시예들에서, CLI(212)는 bash, csh, tcsh, 또는 ksh 타입 쉘을 통해 제공될 수 있다. 쉘 서비스들(214)은 GUI(210) 및/또는 CLI(212)를 통해 사용자에 의해 어플라이언스(104) 또는 운영체제와의 상호 작용을 지원하기 위해 프로그램들, 서비스들, 작업들, 프로세스들 또는 실행가능 명령들을 구비한다.

헬스 모니터링 프로그램(216)은 네트워크 시스템들이 적절히 기능을 하고 있 고 사용자들이 네트워크를 통해 요청된 콘텐트를 수신하고 있음을 감시, 체크, 보고 및 식별하는데 사용된다. 헬스 모니터링 프로그램(216)은 어플라이언스(104)의 행위를 감시하기 위한 로직, 규칙, 기능 또는 동작을 제공하기 위해 하나 이상의 프로그램들, 서비스들, 작업들, 프로세스들 또는 실행가능 명령들을 구비한다. 일부 실시예들에서, 헬스 모니터링 프로그램(216)은 어플라이언스(104)를 통해 전달된 네트워크 트래픽을 인터셉트하여 조사한다. 다른 실시예들에서, 헬스 모니터링 프로그램(216)은 어떤 적합한 수단 및/또는 메커니즘에 의해 암호화 엔진(234), 캐시 관리자(232), 정책 엔진(236), 멀티프로토콜 압축 로직(238), 패킷 엔진(240), 대몬 서비스들(218), 및 쉘 서비스들(214) 중 하나 이상과 인터페이스한다. 이와 같이, 헬스 모니터링 프로그램(216)은 어플라이언스(104)의 어떤 부분의 상태 또는 헬스를 결정하기 위해 애플리케이션 프로그래밍 인터페이스(API)를 호출할 수 있다. 예컨대, 헬스 모니터링 프로그램(216)은 프로그램, 프로세스, 서비스 또는 작업이 액티브 상태이고 현재 구동되고 있는지를 체크하기 위해 상태 질의를 주기적으로 핑 또는 전송한다. 다른 예에서, 헬스 모니터링 프로그램(216)은 어플라이언스(104)의 어느 부분의 조건, 상태 또는 에러를 결정하기 위해 프로그램, 프로세스, 서비스 또는 작업에 의해 제공되는 상태, 에러 또는 히스토리 로그를 체크할 수 있다.

대몬 서비스들(218)은 연속적으로 또는 배경에서 구동되어 어플라이언스(104)에 의해 수신된 주기적인 서비스 요청을 처리하는 프로그램들이다. 일부 실시예들에서, 대몬 서비스는 요청을 다른 프로그램들 또는 프로세스들, 예컨대 적 절하다면 다른 대몬 서비스(218)에 전송할 수 있다. 당업자에 알려진 바와 같이, 대몬 서비스(218)는 연속적이거나 주기적인 시스템 와이드(wide) 기능을 수행하기 위해, 예컨대 네트워크 제어를 수행하기 위해 또는 원하는 작업을 수행하기 위해 참여없이 구동될 수 있다. 일부 실시예들에서, 하나 이상의 대몬 서비스들(218)이 사용자 공간(202)에서 구동되고, 다른 실시예들에서, 하나 이상의 대몬 서비스들(218)이 커널 공간에서 구동된다.

C. 동적으로 발생된 객체들의 캐싱

동적 콘텐트, 예컨대 하나 이상의 동적으로 발생된 객체들은, 도 1에 나타낸 바와 같이 로컬 또는 원격인 하나 이상의 클라이언트(102a-102n)로부터의 객체 요청들을 처리하는 애플리케이션 또는 시작 서버(106a-106n) 및/또는 백엔드 데이터베이스들(도시되지 않음)이라고 하는 서버들에 의해 발생될 수 있다. 그 애플리케이션들 또는 데이터베이스들이 클라이언트들로부터 수신된 입력에 관련된 데이터를 포함한 데이터를 처리함에 따라, 이들 데이터베이스 및 애플리케이션에 의해 서빙된 응답 객체들이 변화될 수 있다. 시작 서버에서 애플리케이션들 또는 데이터베이스들에 의해 발생된 종전 객체들은 더 이상 새롭지 않을 것이며, 따라서 더 이상 캐시에 의해 저장되어서는 안 된다. 예컨대, 동일한 세트의 입력들이 주어지면, 제1 인스턴스의 동적으로 발생된 객체는 제2 인스턴스의 동적으로 발생된 객체와는 다를 수 있다. 다른 예에서, 동일한 객체가 상이한 세트의 입력들에 의해 동적으로 발생될 수 있어, 객체의 제1 인스턴스가 객체의 제2 인스턴스와는 다르게 발생 된다.

네트워크 성능을 향상시키기 위해, 어플라이언스(104)는 후술되는 바와 같이 다양한 방법들을 통해, 동적으로 발생된 콘텐트를 캐싱할 때 생기는 문제들을 처리하도록 설계 및 구성된다. 여기서 설명되는 본 발명의 일부 실시예들에서, 어플라이언스(104)는 캐시에 저장된 동적 발생 콘텐트의 무효화를 보다 효율적이고 효과적이게 하기 위한 하나 이상의 기술들의 세트를 포함한다. 또한, 어플라이언스는 플래시 크라우드에 대한 제어 및 캐싱을 수행하기 위한 기술들을 포함할 수 있다. 캐시 메모리들은 일반적으로 객체에 대한 요청에 대한 모든 응답을, 이런 응답이 캐싱 불가능한 것으로 마킹되어 있지 않는 한, 저장하게 된다. 여기서 설명되는 바와 같이, 동적으로 발생된 콘텐트의 효율적인 캐싱은 시작 서버에서 변화된 캐시 메모리 내의 객체들의 적시(timely) 무효화를 가능하게 하는 기술들을 요구한다. 적시 무효화는, 특히 콘텐트에 대한 변화들이 불규칙적으로 일어나는 경우, 캐시가 진부한 콘텐트의 서빙, 즉 동적으로 발생된 콘텐트와의 특별한 작업을 피하는 것을 가능하게 한다. 동적으로 발생된 콘텐트의 무효화를 보장하기 위한 다수의 기술에 대해 후술한다.

1. 통합 기능

일 양태에서, 본 발명은 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238)의 기능, 로직, 또는 동작들을, 패킷 처리 타이머(242)에 응답하여 고속 계층 2-7 통합 패킷 엔진(240)의 패킷 처리 동작들과 통합하는 기술들에 관한 것이다. 예컨대, 캐시 관리자(232)의 동작들은 예컨대 네트워크 패킷의 수신 또는 송신시 패킷 처리 동작들을 위해 사용되는 패킷 처리 타이머(242)의 시간 간격들 내에서 수행될 수 있다. 일 실시예에서, 패킷 처리 동작들을 통합함으로써 및/또는 패킷 처리 타이머를 사용함으로써, 본 발명의 캐시 관리자(232)는 상세하게 후술되는 바와 같이 매우 짧은 시간 간격으로 줄어든 만기 시간을 가지고 객체들을 캐싱할 수 있다. 다른 실시예들에서, 패킷 처리 타이머(242)에 응답하여 캐시 관리자(232)는 객체를 캐싱하는 매우 짧은 시간 기간 내에 객체를 무효화하라는 무효화 명령을 수신할 수 있다.

도 3A에 도시된 상기 방법 300은, 동작 처리 동안에, 또는 고속 계층 2-7 통합 패킷 엔진 또는 패킷 처리 엔진(240)에 의한 네트워크 패킷의 처리를 위한 시간 간격과 관련하여, 동작을 수행할 것을, 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238)에 요청하기 위한 본 발명의 기술의 일 실시예를 예시한다. 개략적으로, 방법 300의 단계 310에서, 장치(104)는 네트워크 패킷을 수신하거나, 네트워크 패킷을 전송하도록 요청받는다. 단계 315에서, 장치(104)는 패킷 처리 타이머(242)에 응답하여 네트워크 패킷을 처리할 것을 패킷 처리 엔진(240)에 요청한다. 패킷 처리 동작들의 일부로서 또는 그 패킷 처리 동작들과 연관되어, 단계 320에서, 패킷 처리 엔진(240)은 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238)에게 캐싱된 객체에 대해 동작을 수행할 것을 요청한다. 단계 325에서, 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔 진(238)은 여기서 설명되는 본 발명의 기술들 중 어느 하나 또는 그 조합을 포함할 수 있는 요청된 동작을 수행한다. 일 실시예에서, 캐시 관리자(232)는 캐싱된 객체의 무효화를 결정하고, 캐싱된 객체를 무효로서 마킹한다. 일부 실시예들에서, 캐시 관리자(232)는 패킷 처리 엔진(240)에 의한 요청에 응답하여 무효 객체를 플러싱한다. 캐시 관리자(232)가 패킷 처리 타이머(242)에 응답하여 이들 동작들을 수행함에 따라, 객체들의 무효화는 밀리초 정도의 시간 기간 내에서, 그리고 패킷 처리 타이머(242)에 의해 제공되는 시간 간격 정도, 예컨대 10 ms의 만기를 가진 객체들의 경우에 일어날 수 있다.

본 발명의 방법 300을 상세히 설명하면, 단계 310에서, 어플라이언스(104)는 하나 이상의 네트워크 패킷들을 수신하거나 하나 이상의 네트워크 패킷들을 송신한다. 일부 실시예들에서, 어플라이언스(104)는 네트워크(108) 또는 네트워크(110) 상에서 하나 이상의 네트워크 패킷들을 전송할 것을 요청한다. 다른 실시예에서, 어플라이언스(104)는 하나의 포트(266) 상에서 네트워크 패킷을 수신하고, 동일한 포트(266) 또는 상이한 포트(266') 상에 네트워크 패킷을 전송한다. 일부 실시예들에서, 어플라이언스(104)의 패킷 엔진(240)은 하나 이상의 네트워크 패킷들을 전송하거나 전송할 것을 요청한다. 일 실시예에서, 어플라이언스(104)는 패킷을 제1 네트워크(108) 상에서 수신 또는 전송하고, 다른 실시예에서는, 어플라이언스(104)는 제2 네트워크(110) 상에서 패킷을 수신 또는 전송한다. 다른 실시예들에서, 어플라이언스(104)는 동일한 네트워크상에 패킷들을 수신 및 송신한다. 일부 실시예들에서, 어플라이언스(104)는 네트워크 패킷들을 수신하여 하나 이상의 클라이언 트(102a-102n)에 전송한다. 다른 실시예들에서, 어플라이언스(104)는 네트워크 패킷들을 수신하여 하나 이상의 서버(106a-106n)에 전송한다.

단계 315에서, 장치(104)는 장치(104)의 네트워크 포트(266)에서의 네트워크 패킷의 수신시, 또는 장치(104)로부터의 네트워크 패킷을 전송하라는 요청시, 또는 하나 이상의 네트워크 패킷들의 수신 및/또는 전송의 조합시 패킷 처리 엔진(240)의 패킷 처리 동작들을 요청 또는 트리거시킬 수 있다. 일부 실시예들에서, 패킷 처리 엔진(240)의 패킷 처리 동작들은 패킷처리 타이머(242)에 의해 제공되는 신호를 통해 트리거된다. 일 실시예에서, 패킷 처리 타이머(242)는 하나 이상의 네트워크 패킷들의 수신 및/또는 전송과 관련된 인터럽트-구동 또는 이벤트-구동 타이머 기능을 제공할 수 있다. 일부 실시예들에서, 패킷 처리 타이머(242)는 장치(104)를 통해 네트워크 패킷들의 수신 및/또는 전송의 레이트로, 또는 각 패킷 또는 패킷 군이 처리되는 레이트로 구동된다. 이와 같이, 패킷 처리 타이머(242)는 각 세트의 하나 이상의 패킷 처리 동작들 이후에 트리거 또는 리세트될 수 있다. 다른 실시예에서, 패킷 처리 타이머(242)는, 기능 또는 동작을 수행하도록, 예컨대 수신된 패킷을 처리하거나 제출된 패킷을 전송하도록 패킷 처리 엔진(240)을 트리거, 웨이크 업, 또는 시그널링하기 위해 시간 간격, 즉, 동일 또는 가변 시간 간격을 제공한다. 도 2의 장치(104)를 참조하여 후술되는 바와 같이, 패킷 처리 타이머(242)는 밀리초 정도로, 예컨대 유발 시간 간격으로 동작하거나, 10ms 이하의 간격으로 패킷 처리 동작들을 트리거할 수 있다. 본 발명의 패킷 처리 타이머의 그래눌러 타이머 기능은 각종 방식으로 제공될 수 있고 패킷 처리 엔진(240) 의 패킷 처리 동작들에 사용될 수 있다.

본 발명의 방법 300의 단계 320에서, 패킷 처리 엔진(240)은 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234) 및/또는 멀티프로토콜 압축 엔진(238) 중 하나 이상에 동작을 수행할 것을 요청한다. 일 실시예에서, 패킷 처리 엔진(240) 또는 패킷 처리 타이머(242)는 신호 또는 신호들을 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238) 중 하나 이상에 발생해준다. 패킷 처리 엔진(240)은 네트워크 패킷 또는 하나 이상의 패킷들의 패킷 처리 동작 전, 그 동작 동안, 또는 그 동작 후 어느 시점에 동작을 요청 또는 시그널링한다. 일 실시예에서, 패킷 처리 엔진(240)은 패킷 처리 타이머(242)의 트리거시 또는 패킷 처리 타이머(242)에 의해 제공된 시간 간격의 만료시, 그리고 네트워크 패킷에 대해 패킷 처리 동작을 수행하기 전에 요청을 행한다. 다른 실시예에서, 하나 이상의 패킷 처리 동작들을 수행하는 과정 중에, 패킷 처리 엔진(240)은 요청을 행한다. 예를 들면, 동작의 실행 동안에, 예컨대 기능 호 이내에, 패킷 처리 엔진(240)은 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238) 중 하나에 애플리케이션 프로그래밍 인터페이스(API) 호를 행할 수 있다. 다른 실시예들에서, 패킷 처리 엔진(240)은 네트워크 패킷 처리 동작의 완료시 요청을 행한다.

단계 325에서, 요청된 동작은 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238) 중 하나 이상에 의해 수행된다. 일부 실시예들에서, 커널(204)을 통해 제공되는 기능 또는 동작은 예컨대 커널 애 플리케이션 프로그래밍 인터페이스(API)를 통해 실행 요청될 수 있다. 이와 같이, 장치(104)의 기능들은 패킷 처리 타이머(232)를 통해 패킷 처리 타이밍 또는 타이밍 간격으로 수행될 수 있다. 일부 실시예들에서, 요청된 동작은 패킷 처리 엔진(240)의 패킷 처리 동작들과 동기되어 그리고 그 동작들과 함께 수행된다. 예컨대, 패킷 처리 동작들은 요청된 동작의 완료시 또는 요청된 동작으로부터의 응답시 기다리고 계속한다. 다른 실시예들에서, 요청된 동작은 패킷 처리 동작들과 비동기로 수행된다. 예컨대, 패킷 처리 엔진(240)은 동작을 수행하라는 요청을 전송하나, 동작으로부터의 응답을 차단하거나 그 응답을 기다리지는 않는다. 도 3B에 도시된 본 발명의 방법 350을 참조하여 상세히 설명하는 바와 같이, 패킷 처리 엔진(240)은 캐시 관리 기능, 예컨대 객체들의 만료 또는 무효화의 체크, 객체들을 무효로 마킹하는 기능, 또는 무효 또는 만료된 객체들을 플러싱하는 기능을 수행할 것을 캐시 관리자(232)에 요청할 수 있다.

일부 실시예들에서, 패킷 처리 엔진(240)은 단계 320에서 다수의 요청을, 예컨대 제1 요청을 캐시 관리자(232)에 전송하고 제2 요청을 암호화 엔진(234)에 전송한다. 다른 실시예들에서, 패킷 처리 엔진(240)은 단계 320에서, 장치(104)에 의해 분배될 다수의 요청을 포함하는 단일 요청을, 예컨대 커널(230)을 통해 장치(104)의 의도된 구성 요소에 전송한다. 일 실시예에서, 요청들은 서로 후속하여 전달될 수 있다. 다른 실시예에서, 요청들은 이전 요청의 상태, 결과, 성공, 또는 완료에 좌우될 수 있다. 예컨대 정책 엔진(236)에 대한 제1 요청은 네트워크 패킷과 연관된 다른 장치 또는 사용자로부터 네트워크 패킷을 처리하기 위한 정책을 결 정하는데 이용될 수 있다. 정책 엔진(236)의 정책에 기초하여, 캐시에 대한 제2 요청은 제1 요청의 결과에 따라 행해질 수도 행해지지 않을 수도 있다. 패킷 처리 엔진(240)과 함께 장치(104)의 통합 커널 공간(204)에 통합된 캐시 관리자(232), 정책 엔진(236), 암호화 엔진(234), 및/또는 멀티프로토콜 압축 엔진(238)의 경우, 패킷 처리 동작들에 의해 트리거되고 그 동작들과 통합될 수 있는, 여기서 설명되는 장치(104)의 각종 동작들이 있다.

2. 무효화 그래뉼래러티

다른 양태에서, 본 발명은 패킷 처리 타이머에 의해 제공되는 시간 간격들의 그래뉼래러티와 같은 그래눌러 시간 간격을 줄이기 위해 캐시에 의해 저장된 객체들의 만료 시간을 구성하는 능력에 관한 것이고 그 능력을 포함한다. 이 특징을 "무효화 그래뉼래러티"라고 한다. 이와 같이, 일 실시예에서, 본 발명은 매우 짧은 시간 간격으로 줄어든 만료 시간을 가진 객체들을 캐싱할 수 있다. 다른 실시예들에서, 패킷 처리 타이머에 응답하는 캐시 관리자는 또한 객체를 캐싱하는 매우 짧은 시간 기간 내에서 객체를 무효화하라는 무효화 명령을 수신한다. 만료 시간 내에서의 이 미세 그래뉼래러티를 제공함으로써, 본 발명의 캐시는 빈번하게 변화하는, 때때로 1초 내에 여러 번 변화하는 객체들을 캐싱 및 서빙할 수 있다. 한 가지 기술은 무효화 또는 만료 그래뉼래러티가 10 ms 이하로 줄도록 밀리초 정도의 시간 증분으로 동작할 수 있는 본 발명의 장치에 의해 사용되는 패킷 처리 타이머를 레버리징하는 것이다. 본 발명과는 대조적으로, 전통적인 캐시들은 일반적으로 1초 이하의 만료 또는 무효화 그래뉼래러티를 설정하지 않거나 가지고 있지 않다.

이제 도 3B를 참조하면, 패킷 처리 타이머(242) 및/또는 패킷 처리 엔진(240)에 응답하여 캐싱된 객체를 무효화 또는 만료시키기 위한 본 발명의 방법 350의 실시예가 도시되어 있다. 이와 같이, 본 발명의 일부 실시예들에서는, 캐싱된 객체들이 밀리초 정도, 예컨대 10ms 이하로 무효화 또는 만료될 수 있다. 개략적으로, 방법 350의 단계 355에서, 캐시 관리자(232)는 패킷 처리 타이머(242)에 응답하여 패킷 처리 엔진 Z4U를 통해 동작을 수행하라는 신호 또는 요청을 수신한다. 단계 360에서, 캐시 관리자(232)는 동적으로 발생된 객체와 같은 캐싱된 객체가 무효인지 만료인지를 결정한다. 단계 365에서, 객체가 무효이면, 캐시 관리자(232)는 객체를 무효로 마킹하고, 단계 370에서 캐시 관리자(232)로부터 무효 객체를 플러싱한다.

단계 355을 상세히 설명하면, 일부 실시예들에서, 캐시 관리자(232)는 네트워크 패킷 처리 동안에 임의 시점에서 캐시 관련 동작을 수행할 것으로 통보 또는 요청받는다. 일 실시예에서, 단계 355에서, 캐시 관리자(232)는 장치(104)에 의해 수신되거나 전송될 네트워크 패킷의 처리 전에 동작 요청을 수신한다. 다른 실시예에서, 캐시 관리자(232)는 네트워크 패킷의 처리의 완료 시에 동작 요청을 수신한다. 예컨대, 패킷 처리 엔진(240)은 네트워크 패킷의 처리를 완료하고, 타이머(242)의 다음 시간 간격을 기다리기 전에 또는 다음 패킷을 처리하기 전에, 캐시에 동작을 수행할 것을 요청한다. 다른 실시예들에서, 패킷 처리 동작 동안에, 패킷 처리 엔진(240)은 동작 요청을 캐시 관리자(232)에 전달한다. 다른 실시예에서, 캐시 관리자(232)는 캐시 관리자(232)가 동작을 수행하게 하는 신호를 예컨대 패킷 처리 엔진(240) 또는 패킷 처리 타이머(242)로부터 수신한다. 일부 실시예들에서, 신호는 캐싱된 객체를 무효화하거나 캐싱된 객체를 만료시키도록 지시한다.

일부 실시예들에서, 캐시 관리자(232)는 캐시 관리자(232)의 외부 엔티티로부터 캐시 동작을 수생하라는 요청, 예컨대 서버(106a-106n)에 의해 전달되어 패킷 처리 엔진(240)에 의해 처리되는 객체를 무효화하라는 요청을 수신할 수 있다. 일 실시예에서, 캐시 관리자(232)는 객체를 캐싱하는 10 ms 이하 이내, 다른 실시예에서는, 5ms, 2ms 또는 1ms만큼 짧은 시간 이내에 무효화 요청을 수신할 수 있다. 다른 실시예들에서, 캐시 관리자(232)는 예컨대 객체를 무효화시키는 타이머의 만료시 또는 캐시 명령의 처리 동안에 캐시 관리자(232)의 동작 또는 기능에 응답하여 캐시 동작을 수행한다. 다른 실시예들에서, 캐시 관리자(232)는 캐시 동작을 개시시키기 위해 장치(104)의 패킷 처리 타이머(242)를 사용한다. 예컨대, 타이머(242)는 타이머(242)에 의해 설정될 수 있는 어느 시간 간격으로 캐싱된 객체의 무효화 또는 만료를 체크하도록 캐시를 트리거하거나 캐시에 통보할 수 있다. 일 실시예에서, 타이머(242)는 설정되는 10ms 이하, 또는 다른 실시예에서, 설정되는 5ms, 2ms, 또는 1ms만큼 짧은 시간 내에 캐시를 트리거하거나 통보하도록 설정될 수 있다. 일부 실시예들에서, 시작 서버(106a-106n)는 객체의 만료 시간을 설정할 수 있다. 다른 실시예들에서, 어플라이언스(104) 또는 클라이언트(102a-102n)는 객체의 만료 시간을 설정할 수 있다.

단계 360에서, 캐시 관리자(232)는 캐시에 저장된 객체의 무효화 또는 만료 를 결정한다. 일부 실시예들에서, 캐시 내의 객체는 타이머의 만료에 기초하여 무효화된다. 일 실시예에서, 캐시 관리자(232)는 객체 타이머의 만료에 기초하여 무효화 명령을 발생할 수 있다. 다른 실시예에서, 캐시에 저장된 객체는 타이머, 예컨대 패킷 처리 타이머(242)로 설정된 타이머의 만료에 응답하여 캐시 관리자(232)에 의해 자동으로 무효화된다. 일부 실시예들에서, 패킷 처리 타이머(242)에 응답하여, 캐시 관리자(232)는 캐싱된 객체들에 대해 타이머 만료를 체크한다. 일 실시예에서, 캐시 관리자(232)는 객체 타이머가 만료된 것으로 결정하고, 다른 실시예에서, 캐시 관리자(232)는 객체 타이머가 만료되지 않은 것으로 결정한다. 다른 실시예에서, 패킷 처리 타이머(242)의 제2 트리거 또는 제2 타이머 간격에 응답하여 캐시 관리자(232)는 이전에 체크된 객체 타이머가 만료되는지 제2 시간을 체크할 것이다.

일부 실시예들에서, 캐시 관리자(232)는 무효화 명령을 분석, 해석, 액세스, 판독 또는 처리하거나, 캐시 내의 무효화할 객체를 식별하도록 요청한다. 일 실시예에서, 캐시 관리자(232) 외부의 엔티티는 객체를 무효화하기 위해 무효화 명령을 캐시 관리자(232)에게 발생해준다. 다른 실시예에서, 외부 엔티티는 패킷 처리 타이머(242)에 응답하여 무효화 명령을 발생할 수 있다. 객체가 유효이거나, 무효화되지 않은 경우, 캐시 관리자(232)는 요청에 응답하여 객체를 무효화한다. 일부 실시예들에서, 캐시 관리자(232)에 의해 처리되는 무효화 요청은 이 요청을 처리하는 패킷 처리 엔진(240)의 패킷 처리 동작들에 응답하며, 이 동작은 패킷 처리 타이머(242)에 응답할 수 있다.

단계 365에서, 캐시 관리자(232)는 객체를 무효로서 마킹한다. 캐시 관리자(232)는 각 객체를 어떤 적합한 또는 원하는 방식으로 무효로서 마킹할 수 있다. 일 실시예에서, 객체는 상기 저장된 객체의 플래그, 속성, 또는 특성을 설정함으로써 무효로 마킹된다. 예컨대, 플래그는 객체가 무효임을 캐시 관리자(232)에게 식별해 주는 값으로 설정될 수 있다. 다른 실시예에서, 객체는, 무효 객체를 저장하기 위한 캐시 영역 또는 부분으로 객체를 이동시킴으로써 무효로 마킹될 수 있다. 다른 실시예들에서, 캐시 관리자(232)는 데이터베이스 또는 링크된 리스트 또는 임의 타입 및 형태의 데이터 구조에 의해 저장된 객체의 무효 및/또는 유효 상태를 식별 또는 추적할 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 캐시에 저장된 하나 이상의 객체들의 유효성 또는 무효성을 식별 또는 추적하기 위해 하나 이상의 객체들을 이용한다. 다른 실시예에서, 객체는, 상기 저장된 객체를 변경, 수정, 변화시킴으로써, 예컨대 사용될 수 없도록 객체의 일부를 삭제 또는 제거함으로써, 또는 객체의 이름을 변경 또는 변형시킴으로써 무효로 마킹된다.

단계 370에서, 캐시 관리자(232)는 일부 실시예들에서, 무효로 마킹된 객체들을 캐시로부터 플러싱한다. 다른 실시예에서, 캐시 관리자(232)는 예컨대 클라이언트(102a-102n)에 의한 객체에 대한 요청시 캐시로부터 무효 객체를 플러싱한다. 일부 실시예들에서, 캐시 관리자(232)는 객체의 무효화 또는 만료 이후 수신된 객체의 갱신된 카피 또는 버전으로 무효 객체를 덮어쓴다. 다른 실시예에서, 캐시 관리자(232)는 캐시 메모리의 동일한 부분에 다른 객체를 저장함으로써 무효 객체에 의해 점유된 캐시 메모리를 재사용한다. 또 다른 실시예에서, 캐시 관리 자(232)는 무효로 마킹된 객체를 플러싱하지 않으나, 캐시의 메모리 또는 기억 장치에 저장된 객체를 유지시킨다.

방법 350은 무효화 그래뉼래러티를 제공하기 위해 패킷 처리 타이머에 응답하여 및/또는 패킷 처리 동작들과 함께 수행되는 캐싱된 객체들의 무효화 및 플러싱을 설명하지만, 여기서 설명되는 장치(104)의 어떤 다른 동작뿐만 아니라 어떤 캐시 동작 및 캐시 관리 기술들은 패킷 처리 타이머에 의해 제공되는 미세 그래눌러 시간 간격으로 실행될 수 있다. 일부 실시예들에서, 캐싱된 객체들의 무효화 또는 만료는 100ms만큼 짧은 시간 간격으로 일어날 수 있고, 다른 실시예에서는 50ms만큼 짧은 시간 간격으로 일어날 수 있다. 일부 실시예들에서, 캐싱된 객체들의 무효화 또는 만료가 25 ms만큼 짧은 시간 간격으로 일어날 수 있으나, 다른 실시예들에서는, 10 ms만큼 시간 간격으로 일어날 수 있다. 다른 실시예들에서, 캐싱된 객체들의 무효화 또는 만료가 5 ms만큼 시간 간격으로 일어날 수 있으나, 또 다른 실시예들에서는,3, 2, 또는 1 ms 만큼 짧은 시간 간격으로 일어날 수 있다.

위에서 도 3A 및 도 3B를 참조하여 방법 300 및 방법 350에서 설명한 바와 같이 매우 짧은 시간 증분 경과 후 객체를 무효화하기 위한 용량을 포함함으로써, 동적으로 발생된 콘텐트의 향상된 캐싱이 가능해진다. 일부 동적 콘텐트는 사실상 매우 짧은 시간 기간 동안 저장되어 캐시로부터 서빙되는 것으로 수정 가능하다. 그러나, 이와 같은 콘텐트를 성공적으로 캐싱하기 위해, 본 발명의 일 실시예에 따른 접근법은 객체가 무효화되어 캐시 메모리로부터 플러싱되기 전에 매우 짧은 시간 기간 동안 캐싱 객체들을 저장한다. 예컨대, 동적으로 발생된 객체들은 1초만 큼 긴 시간 동안 캐싱 가능할 수 있으나, 더 긴 시간은 계속 변화하는 콘텐트에 대해서는 종종 받아들일 수 없다. 일 실시예에서, 본 발명의 접근법은 1초의 짧은 시간 부분들 이후 캐싱된 콘텐트를 무효화하거나 만료시키는 것을 포함한다. 일 예로서, 애플리케이션(100)이 동적 응답을 발생하는데 수 밀리초를 소요하면, 캐시는 데이터의 새로움과의 타협 없이 100 밀리초의 기간 이하의 기간 동안 그 응답을 저장 및 서빙할 수 있다. 새로운 객체를 발생하는데 걸리는 시간보다 짧기 때문에 100 밀리초 기간 동안에 발생되는 새로운 객체는 없을 것이다. 따라서, 어플라이언스(104)는 그 기간 동안에 종전 객체를 서빙하도록 설정될 수 있다. 매우 짧은 시간 증분까지 다운시켜 무효화시키는 어플라이언스(104)의 능력은 반복 가능 판독 또는 직렬화 판독을 가능하게 하기 위해 데이터베이스 상호작용 분리 레벨이 설정되는 애플리케이션 환경에 매우 유용하다.

3. 무효화 명령들

전통적인 캐싱 기술은 관리자에 의해 일반적으로 구성되거나 객체를 서빙한 서버로부터 수신된 콘텐트에 대한 미리 정해진 만료 시간에 기초하여 저장된 콘텐트를 무효화한다. 동적으로 발생된 콘텐트를 보다 효율적으로 캐싱하기 위해 콘텐트를 무효화하기 위한 본 발명의 다른 기술에 대해 후술한다. 본 발명의 기술은 캐시 내의 하나 이상의 이전에 저장된 객체들을 실시간으로 무효로 식별하는 무효화 명령을 어플라이언스(104)에서 수신하는 능력을 포함한다. 예컨대, 무효화 명령은 클라이언트에 전송되는 네트워크 패킷을 통해 전달될 수 있고 또는 서버에 의 해 행해진 애플리케이션 프로그래밍 인터페이스(API) 호가 어플라이언스에 전달될 수 있다. 이는 객체가 서빙된 시간에 객체 헤더에 포함하는 캐시 만료 시간을 서버가 간단히 설정하는 전통적인 접근법과는 다르다.

본 발명의 기술은 도 4A 및 도 4B에 보다 구체적으로 예시되어 있다. 도 4는 컴퓨터 메모리 캐시와 같은 캐시를 유지하기 위한 방법을 예시한 흐름도이다. 개략적으로 그리고 단계 410에 따라, 이전에 시작 서버(106a-106n)로부터 서빙된, 동적으로 발생된 객체들이 캐시에 저장된다. 예컨대, 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않을 수 있고, 그렇지 않으면, 캐시 또는 캐시 제어 정보를 포함한다. 단계 420에서, 무효화 명령이 캐시 또는 캐시 관리자(232)에 수신된다. 무효화 명령은 하나 이상의 이전에 서빙된 객체들을 무효한 것으로 식별한다. 단계 430으로서, 무효화 명령에 응답하여, 캐시 또는 캐시 관리자(232)는 식별된 객체를 무효로 마킹한다.

상세히 설명하면, 단계 410에서, 캐시 관리자(232)는 임의 소스로부터 수신, 획득 또는 전달된 동적으로 발생된 객체를 캐시 메모리 소자에 저장한다. 일부 실시예들에서, 동적으로 발생된 객체는 서버(106a-106n)로부터 발생 및 서빙될 수 있다. 다른 실시예들에서, 동적으로 발생된 객체는 클라이언트(102a-102n)에 의해 발생되어 전달될 수 있다. 일부 실시예들에서, 어플라이언스(104)의 다른 부분, 구성 요소 또는 프로세스는 객체를 발생하여 캐시에 저장한다. 다른 실시예들에서, 동적으로 발생된 객체는 네트워크상의 다른 어플라이언스(104) 또는 다른 컴퓨팅 장치에 의해 발생되어, 어플라이언스(104)에 전송 또는 전달될 수 있다. 일부 실 시예들에서, 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않거나 캐싱 불가능으로 식별된다. 다른 실시예들에서, 동적으로 발생된 객체는 캐싱 가능으로 식별되거나 캐시 제어 하에 놓인다.

단계 420에서, 캐시 관리자(232)는 캐시에 저장된 이러한 동적으로 발생된 객체를 무효화하기 위해 객체를 식별하는 무효화 명령을 수신한다. 일 실시예에서, 무효화 명령은 객체가 무효이거나 진부할 수 있음을 캐시에 나타내는 임의 타입의 지시 또는 명령을 포함할 수 있다. 일부 실시예들에서, 무효화 명령은 객체를 식별하고, 또한 객체가 무효인 시간뿐만 아니라, 객체의 어느 부분들이 무효일 수 있는지를 식별한다. 일 실시예에서, 캐시 관리자(232)는 시작 서버(106a-106n)에 의해 원격 호출될 수 있는 애플리케이션 프로그래밍 인터페이스(API)를 제공한다. 일부 실시예들에서, 캐시 관리자(232)는 명령들을 수신하고 하나 이상의 네트워크 패킷을 통해 명령들에 응답하는 임의 타입 및 형태의 프로토콜을 제공할 수 있다. 일 실시예에서, 캐시 관리자(232) 또는 장치(104)는 무효화 명령들을 수신 및 처리하기 위한 XML(Extensible Markup Language) API 인터페이스를 제공한다. 예컨대, 캐시 관리자(232)는 웹 서비스 인터페이스를 제공할 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 식별 응답, 상태 또는 다른 응답을 시작 서버(106a~106n)에 전송함으로써 무효화 명령에 응답한다. 다른 실시예들에서, 캐시 관리자(232)는 무효화 명령에 응답하지 않는다. 일 실시예에서, 객체는 시작 서버(106a-106n)에서 구동되는 애플리케이션이 예컨대 객체의 새로운 또는 갱신된 버전을 발생함으로써 상기 저장된 객체를 진부하게 만든 액션을 수행하면 무효로 마 킹된다. 이는 예컨대, 뉴스 편집자들이 빠르게 전개되는 뉴스 스토리로 바꾸고 스토리의 가장 최근의 버전이 클라이언트들에게 서빙되고 있는지를 식별하고자 할 때 일어날 수 있다

무효화 명령들은 객체를 발생한 애플리케이션에 의해, 다른 서버(106a-106n) 또는 다른 어플라이언스(104)에 의해 시작 서버로부터 발생될 수 있다. 일 실시예에서, 시작 서버(106a-106n)는 시작 서버(106a-106n) 상에서의 동적으로 발생된 객체의 변화에 응답하여 자동으로 무효화 명령을 캐시(232)에 발생 또는 전달한다. 무효화 명령은 서버(106a-106n) 및 어플라이언스(104)의 외부의 관리 제어에 의해 발생될 수 있다. 예컨대, 관리 제어는 네트워크상에서 구동되고 그리고 관리자 콘솔과 같은 어플라이언스(104)와 통신하는 임의 타입 및 형태의 프로그램 또는 애플리케이션일 수 있다. 또한, 클라이언트(102a-102n)는 무효화 명령을 발생하거나 어플라이언스(104) 또는 캐시 관리자(232)에 전달할 수 있다. 예컨대, 시작 서버에서 요청 객체들에 대한 변화를 야기한다고 클라이언트(102a-102n)가 알고 있는 행위를 클라이언트가 취해야 한다면, 클라이언트는 무효화 명령을 전달할 수 있다. 캐시에 저장된 객체는 캐시에서 국부적으로 실행되거나 XML API 인프라구조를 사용하여 원격 호출된 사용자 명령의 캐시로의 전송에 의해 무효화될 수 있다.

단계 430에 따라, 캐시에 저장된 객체, 예컨대, 무효로 식별된 이전에 서빙된 동적으로 발생된 객체는 무효화 명령에 응답하여 그와 같이 마킹된다. 무효 객체는 캐시로부터 요청 클라이언트로 제공되지 않고, 대신에 시작 서버로부터 직접 서빙된다. 캐시 관리자(232)는 각 객체를 어떤 적합한 또는 원하는 방식으로 무효로 마킹할 수 있다. 일 실시예에서, 객체는 상기 저장된 객체의 플래그, 속성, 또는 특성을 설정함으로써 무효로 마킹된다. 예컨대, 플래그는 캐시 관리자(232)에게 객체가 무효임을 나타내는 값으로 설정된다. 다른 실시예에서, 객체는 객체를 무효 객체들을 저장하기 위한 캐시의 영역 또는 부분으로 이동시킴으로써 무효 객체로서 마킹될 수 있다. 다른 실시예들에서, 캐시 관리자(232)는 데이터베이스 또는 링크된 리스트 또는 임의 타입 및 형태의 데이터 구조에 의해 저장된 객체의 무효 및/또는 유효 상태를 식별 또는 추적할 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 캐시에 저장된 하나 이상의 객체들의 유효성 또는 무효성을 식별 또는 추적하기 위해 하나 이상의 객체들을 사용한다. 다른 실시예에서, 객체는 상기 저장된 객체를 변화, 수정 또는 변경, 예컨대 사용될 수 없도록 객체의 일부를 삭제 또는 제거하고, 또는 객체의 이름을 변경 또는 변형함으로써 무효로 마킹된다.

일부 실시예들에서, 어플라이언스(104)는 후속적으로 무효로 마킹된 객체들을 캐시로부터 플러싱한다. 다른 실시예들에서, 어플라이언스(104)는 예컨대 클라이언트(102a-102n)에 의해 객체에 대한 요청시 캐시로부터 무효 객체를 플러싱한다. 일부 실시예들에서, 어플라이언스(104)는 무효 객체를 객체의 갱신된 카피 또는 버전과 중복기록한다. 다른 실시예에서, 어플라이언스(104)는 다른 동적으로 발생된 객체를 캐시 메모리의 동일한 부분에 저장함으로써 무효 객체에 의해 캐시 메모리를 재사용한다.

본 발명의 캐시 관리자(232)의 명령 무효화 API의 경우, 어플라이언스(104) 와 통신하는 컴퓨팅 장치 또는 사용자는 캐시에 저장된, 동적으로 발생된 객체와 같은 객체를 무효화할 것을 요청할 수 있다. 이와 같이, 캐시에 저장된 객체들의 무효화는 미리 결정된 구성 만료 또는 무효화 시간 기간을 이용하지 않고 실시간으로 제어될 수 있다. 따라서, 이들 기술들을 이용하여, 캐싱된 객체들의 수명은 데이터베이스들 또는 원래 애플리케이션 서버들과 같은 외부 애플리케이션 처리 노드들로부터 제어될 수 있다. 예컨대, 어플라이언스(104)는 데이터베이스와 함께 동작하도록 구성될 수 있어, 데이터베이스의 변화는 특별한 객체 또는 객체들을 플러싱하기 위해 자동으로 네이터베이스(또는 애플리케이션)로부터 어플라이언스(104)로 무효화 명령을 트리거할 수 있다.

4. 무효화 명령을 이용한 그룹들의 무효화

본 발명의 다른 실시예에서, 어플라이언스(104)는 캐시에 의해 저장된 객체들의 그룹을 동시에 식별하고 무효화한다. 전통적인 캐시 메모리에 저장된 객체들은 각각 객체가 진부한지를 판단할 때 캐시에 의해 개별적으로 그리고 별개로 취급된다. 각 객체는 아이템이 캐시 메모리로부터 플러싱되는 지정된 만료 시간(일반적으로 서버에 의해 설정되어 캐시의 테이블에 저장됨)에 도달한다. 그러나, 이 전통적인 접근법은 동적으로 발생된 콘텐트를 캐싱하는 시도에서 생기는 문제들을 성공적으로 처리하기에는 효율적이지 않고 매우 불충분하다.

도 4B는 다른 실시예 캐시, 예컨대 컴퓨터 메모리 캐시를 유지하기 위한 본 발명의 방법의 다른 실시예를 예시하며, 여기서 어플라이언스(104)는 시작 서 버(106a-106n)로부터 이전에 서빙된 관련 객체들의 그룹들을 생성, 저장 및 무효화하는 능력을 갖는다. 개략적으로, 단계 410에서, 객체, 예컨대 시작 서버(106a-106n)로부터 서빙된 동적으로 발생된 객체가 캐시에 저장된다. 단계 412에서, 캐시 관리자(232)는 캐시에 저장된 이전에 서빙된 객체들의 그룹을 형성한다. 일 실시예에서, 그룹은 상세히 후술되는 바와 같이 하나 이상의 객체 결정인자들과 연관될 수 있고 또는 그 객체 결정인자들에 의해 식별될 수 있다. 단계 414에서, 캐시 관리자(232)는 객체 그룹들의 레코드를 유지한다. 단계 422에서, 캐시 관리자(232)는 객체 그룹을 무효화하라는 무효화 명령을 수신한다. 단계 432에서, 캐시 관리자(232)는 무효화 명령에 응답하여 객체 그룹들을 무효로 마킹한다.

단계 410은 도 4A에서와 동일하며, 여기서 객체, 예컨대 시작 서버(106a-106n)로부터 이전에 서빙된, 동적으로 발생된 객체들은 어플라이언스(104)의 캐시에 저장된다. 일부 실시예들에서, 객체들 중 하나 이상은 캐싱 가능으로 식별될 수 없고, 또는 캐시 또는 캐시 제어 정보를 가질 수 없다. 예컨대, 서버(106a-106n)는 동적으로 발생된 객체들은 캐싱 되지 않는 것으로 가정할 수 있다.

단계 412에 따라, 어플라이언스(104)는 시작 서버(106a-106n)로부터 이전에 서빙되어 캐시에 저장된 한 세트의 객체들로부터 그룹을 형성한다. 어떤 적합한 또는 원하는 세트의 객체들은 그룹을 형성하기 위해 서로 연관될 수 있다. 예컨대, 웹 페이지를 서빙하기 위해 웹 페이지와 연관되어 발생된, 동적으로 발생된 객체들은 그룹을 형성할 수 있다. 일부 실시예들에서, 객체는 다중 그룹들과 연관될 수 있다. 다른 실시예들에서, 하나의 객체들의 그룹은 다른 객체 그룹들의 하 위 세트를 형성할 수 있다. 일부 실시예들에서, 객체들의 형성된 그룹은 동일한 서버(106a-106n)로부터 서빙된 객체들을 가지나, 다른 실시예들에서는, 객체들의 형성된 그룹이 상이한 서버(106a-106n)로부터 서빙된 객체들을 갖는다. 다른 실시예들에서, 객체들의 형성된 그룹은 클라이언트(102a-102n)로부터의 객체들, 서버(106a-106n)로부터의 객체들, 또는 클라이언트(102a-102n) 및 서버(106a-106n)에 의해 발생되거나 이들로부터 서빙되는 객체들을 포함할 수 있다. 일 실시예에서, 그룹 내의 하나의 객체는 정적이고 그룹 내의 다른 객체는 동적으로 발생된다. 일부 경우들에서, 그룹 내의 하나의 객체는 캐싱 가능으로 식별되지 않고 그룹 내의 다른 객체는 캐싱 가능으로 식별된다. 다른 경우들에서, 그룹 내의 객체들은 서버(106a-106n)에 의해 제공되는 기능 또는 애플리케이션에 따라 논리적으로 연관될 수 있다. 다른 경우에서, 그룹 내의 객체들은 동일한 클라이언트(102a-102n) 또는 동일한 사용자와 연관될 수 있다.

단계 414에서, 객체 그룹의 레코드가 유지된다. 객체들의 그룹의 레코드를 기록 및 유지하거나 객체들을 연관시키기 위한 각종 기술들이 여기서 설명되는 본 발명의 동작을 실시하는데 이용될 수 있다. 일 실시예에서, 레코드는 예컨대, 룩업 테이블에 직접 유지될 수 있다. 다른 실시예에서, 레코드들은 해쉬 테이블 포맷으로 표현될 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 데이터베이스, 또는 메모리 내의 데이터 구조 또는 객체에서 객체들의 연관성을 유지한다. 다른 실시예들에서, 그룹 내의 각 객체의 플래그, 특성 또는 속성은 그룹을 식별하는 값, 예컨대 그룹과 같은 값, 또는 그룹의 이름 또는 식별자, 예컨대 보다 상세하게 후술 되는 그룹의 객체 결정인자를 식별 또는 참조하는 값으로 할당 또는 설정된다. 일부 실시예들에서, 객체들의 그룹은 그룹을 홀딩한 것으로 식별한 캐시 메모리의 일부에 배열, 배치, 또는 위치된다

단계 422에서, 무효화 명령이 어플라이언스(104) 또는 캐시 관리자(232)에 수신된다. 도 4B에 기술된 실시예에 따라, 무효화 명령은 하나 이상의 객체들을 무효이거나 진부한 것으로 식별한다. 일부 실시예들에서, 무효화 명령은 객체들의 그룹의 이름 또는 식별자를 참조, 식별 또는 지정한다. 일 실시예에서, 무효화 명령은 그룹 내의 모든 객체들을 무효화하라는 단일 무효화 요청을 포함한다. 다른 실시예에서, 무효화 명령은 무효화할 그룹 내의 하나의 객체를 식별한다. 다른 실시예들에서, 무효화 명령은 복수의 그룹 내의 객체들을 무효화하라는 복수의 무효화 요청을 포함한다.

단계 432에 따라, 무효화 명령이 그룹의 객체를 무효로, 그룹 내의 각 객체를 무효로, 또는 그룹을 무효로 참조, 식별 또는 지정하면 이전에 서빙된 객체들의 그룹은 무효로 마킹된다. 일부 실시예들에서, 무효화 명령이 그룹 내의 객체를 무효로 식별하면, 캐시 관리자(232)는 객체를 무효로 마킹한다. 다른 실시예들에서, 무효화 명령이 그룹 내의 객체를 무효로 식별하면, 캐시 관리자(252)는 객체 그룹들을 무효로 또는 그룹 내의 각 객체를 무효로 마킹한다. 또 다른 실시예들에서, 캐시 관리자(232)는 단지 하나 이상의 무효화 명령들을 통해 복수의 객체들이 무효로 식별될 때 객체 그룹을 무효화할 수 있다. 다른 실시예에서, 무효화 명령은 그룹의 이름 또는 식별자를 지정할 수 있고, 캐시 관리자(232)는 그룹을 무효로 마킹하거나 그룹 내의 각 객체를 무효로 마킹한다.

일 실시예에서, 어플라이언스(104) 또는 캐시 관리자(232)는 무효로 마킹된 객체들의 그룹을 캐시 메모리로부터 플러싱한다. 일부 실시예들에서, 그룹 내의 객체들은 그룹 내의 각 객체가 무효로 마킹된 경우에만 캐시 메모리로부터 플러싱될 수 있다. 다른 실시예들에서, 그룹의 하나의 객체가 무효로 마킹되면, 전체 그룹이 플러싱된다. 다른 실시예에서, 무효로 마킹된 객체 그룹 또는 그룹 내의 객체는 클라이언트(102a-102n)에 의한 객체 그룹 또는 그룹 내의 객체에 대한 요청의 수신시 플러싱될 수 있다. 다른 실시예들에서, 무효로 마킹된 객체 그룹 또는 그룹 내의 객체는 하나 이상의 새로운 그룹 내의 객체들을 제공하는 서버(106a-106n)로부터 응답의 수신시 플러싱될 수 있다.

위에서 설명된 실시예들의 일 예는 다음과 같다. 소비자 자원 관리("CRM") 애플리케이션들은 자원 관리의 모든 측면들을 추적 및 평가하기 위해 많은 회사에 의해 사용된다. 종종, CRM 애플리케이션은 인터넷을 포함한 전용 및 공용 네트워크를 통해 구현 및 액세스된다. 따라서, 빈번하게 액세스되는 상당량의 데이터에 대한 액세스를 제공하는 이들 애플리케이션은 이러한 애플리케이션들에 의해 발생된 데이터를 캐싱하여 이익을 얻는다. 예컨대, 판매 리포트들은 빈번하게 발생되어 원격 접속된 사용자들에 서빙된다. 이들 판매 리포트는 이러한 애플리케이션 서버들 및/또는 내재 데이터베이스들에 포스팅된 판매 정보로부터 데이터를 컴파일링함으로써 해당 애플리케이션에 의해 생성된다. 많은 사용자가 캐싱 없이 동일한 문서(즉, 일정한 판매 리포트)를 요구하면, 애플리케이션 서버는 각 요청에 대한 객체를 다시 발생해야 한다. 그러나, 이러한 객체들이 캐시에 저장되면, 캐시가 요청 클라이언트에 가깝게 배치됨에 따라 잠재적으로 가치 있는 대역폭을 포함해서 애플리케이션 및 데이터베이스 프로세싱이 절약된다.

새로운 판매가 시작 서버에서 구동되는 애플리케이션에(또는 내재 데이터베이스) 포스팅될 때마다, 판매 리포트의 정보는 갱신될 필요가 있기 때문에, 상기 객체들을 캐싱하는 문제가 생긴다. 결과적으로, 이들 애플리케이션 서버들을 지원하는 캐시에 저장될 수 있었던 모든 판매 리포트들은 무효화되어야 하고 콘텐트가 캐시 메모리에서 플러싱되어야 한다. 그러나, 전통적인 캐싱 접근법은 내재 데이터베이스 또는 애플리케이션에 대한 변화가 일어나려고 할 때를 정확하게 결정할 수 있는 방법을 갖고 있지 않아 동적 콘텐트의 새로움을 적절히 추정할 수 없다. 데이터베이스 또는 애플리케이션 또는 시작 서버에서 변화가 일어날 때마다, 캐시는 변화가 일어났는지 그리고 어느 객체들의 그룹이 이러한 변화의 결과로서 무효화되어야 하는지를 식별할 수 있어야 한다. 상기한 바와 같이, 이전에 서빙된 객체들의 그룹들에 링크된 객체 결정인자들을 포함하는 무효화 명령들의 발생은 이 요구를 충족할 수 있다.

관련 객체들의 다수 그룹은 단일 계층 레벨로 형성될 수 있다. 대안으로, 하위 객체 그룹은 다수의 계층 레벨을 생성하기 위해 형성될 수 있다. 일 실시예에서, 상기 그룹 또는 하위 객체 그룹은 사용자에 의해 미리 지정될 수 있다. 다른 실시예에서, 사용자는 어플라이언스(104)가 관련 객체들의 그룹들을 자동으로 형성하고 객체 결정인자들을 그 그룹들과 연관시키는 규칙들을 설정할 수 있다.

5. 클라이언트 요청 또는 응답에서의 객체 결정인자들의 식별

본 발명의 실시예는 또한 객체들의 그룹들을 발생하고 파라미터화된 무효화를 구현함으로써 애플리케이션 서버(106a-106n)(및/또는 내재 데이터베이스)에서의 상태 변화의 영향을 받는 모든 객체들을 식별할 수 있는 필요성을 처리한다. 이 실시예에서, 객체 또는 미리 정해진 객체 그룹은, 캐시가 객체 결정인자를 식별하기 위해 분석하는 예컨대 클라이언트로부터의 인터셉트된 HTTP 요청에 의해 무효화될 수 있다. 용어 "객체 결정인자"는 하나의 객체 또는 객체 세트를 예컨대 고유하게 참조, 식별, 또는 지정하는 정보, 데이터, 데이터 구조, 파라미터, 값, 데이터 패턴, 요청, 응답, 또는 명령을 말한다. 일부 실시예들에서, 객체 결정은 객체와 연관될 수 있는 통신에서 바이트들 또는 문자들의 패턴이고, 이 패턴은 통신이 객체와 연관되어 있고 객체를 참조한다는 것을 고유하게 식별하는데 사용된다. 일 실시예에서, 객체 결정인자는 객체 결정인자가 연관된 캐시 관리자(232)에 저장된 이전에 서빙된 객체들의 그룹에 대한 변화가 시작 서버에서 일어났는지 아니면 일어날 것인지를 나타낸다. 일부 실시예들에서, 객체 그룹 내의 객체들은 객체들이 적어도 하나의 객체 결정인자와 연관되어 있다는 점에서 관련성이 있다. 객체 결정인자들의 한정적이지 않은 특정 예 및 그 이용에 대한 예를 보다 상세하게 후술한다.

본 실시예의 일부 실시예들에서, 객체 결정인자들 클라이언트 요청 또는 응답에 포함 또는 삽입된 미리 정의된 파라미터 또는 데이터 구조들이다. 다른 실시 예들에서, 클라이언트(102a-102n), 서버(106a-106n) 또는 어플라이언스(104)는 하나 이상의 객체 결정인자들, 예컨대 객체 결정인자를 나타내는 미리 정의된 스트링 또는 문자 세트를 통신에 삽입한다. 객체 결정인자들은 이러한 요청이 시작 서버(106a-106n) 또는 이 서버에 링크된 데이터베이스들에 저장된 객체들의 상태 변화를 야기하는 효과를 가지는지를 나타낸다. 일 실시예에서, 요청에서의 객체 결정인자의 존재는 객체에 대해 변화가 일어났거나 일어날 것임 나타낸다. 다른 실시예에서, 신택스, 구조, 파라미터, 또는 객체 결정인자의 값은 객체에 대해 변화가 일어났거나 일어날 것임 나타낸다. 일 실시예에서, 캐시는 객체 클라이언트(102a-102n)로부터 요청을 수신한다. 요청은 시작 서버 또는 애플리케이션 서버의 상태를 변화시키는 것으로 캐시가 인식한 일정한 파라미터들 또는 값들(객체 결정인자들)을 포함할 수 있으며, 여기서 상기 변화로 인해, 이러한 시작 서버 또는 애플리케이션 서버(106a-106n)에 의해 이전에 발생된 캐시 관리자(232)에 의해 저장된 관련 객체들은 진부해진다. 사용자에 의해 설정된 무효화 정책에 따라, 파라미터들(객체 결정인자들)은 캐시에 의해 저장된, 하나 이상의 이전에 서빙된 객체들 또는 객체 그룹의 무효화를 시작 서버캐시에 의해 요청할 수 있다. 캐시는 이 상태 변화의 영향을 받는 해당 객체들 (즉, 객체 결정인자에 링크된 객체들 또는 객체 그룹)을 식별하고, 객체들 각각을 무효로 마킹하거나 캐시 메모리로부터 이러한 객체들을 플러싱하는 방법을 통해 이들 객체들을 무효화하도록 구성된다.

위에서 설명된 기술이 도 4C에 예시되어 있다. 여기서 설명되는 다른 실시예들의 경우에서와 같이, 단계 410은 객체들, 예컨대 시작 서버로부터 이전에 서빙 된, 동적으로 발생된 객체들을 캐시에 저장하는 것을 포함한다. 객체들은 시작 서버(106a-106n)에서 구동되는 애플리케이션에 의해 발생될 수 있고, 또는 예컨대, 시작 서버(106a-106n)에 의해 액세스되는 데이터베이스로부터 얻을 수 있다. 일부 실시예들에서, 동적으로 발생된 객체들은 캐싱가능한 것 식별되거나 캐싱 가능으로 식별되지 않는다.

단계 421에 따라, 캐시는 클라이언트와 서버 간의 통신, 예컨대 클라이언트로부터의 요청 또는 서버로부터의 응답을 인터셉트하거나 수신한다. 일부 실시예들에서, 요청은 지정된 객체를 위한 것으로, 객체는 이전에 서빙되어 캐시에 저장되어 있다. 다른 실시예에서, 통신은 요청된 객체를 가지고 있는 서버로부터의 응답을 포함한다. 일 실시예에서, 이러한 수신 또는 인터셉트는 설정된 캐싱 프로토콜 및 통신 규격에 따라 일어난다. 이러한 요청, 응답 또는 통신의 수신시 캐시 관리자(232) 또는 어플라이언스(104)가 일반적으로 응답 또는 통신을 수신하는 것으로 설명될 수 있으나, 캐시(232) 또는 어플라이언스(104)는 캐시에 직접 또는 명확하게 전달되지 않더라도 어떤 적합한 수단 및/또는 메커니즘에 의해 요청, 응답 또는 통신을 인터셉트 또는 얻을 수 있다.

단계 423에서, 객체 결정인자는 인터셉트된 통신으로 식별된다. 캐시 관리자(232)는 통신에서 하나 이상의 객체들 결정인자들을 결정 또는 식별하기 위해 인터셉트된 통신을 추출, 해석, 분석, 액세스, 판독 또는 처리할 수 있다. 통신의 파라미터, 값, 신택스, 데이터, 구조 또는 하나 이상의 문자 세트를 객체 결정인자를 식별하는데 이용할 수 있다. 일 실시예에서, 캐시 관리자(232)는 클라이언 트(102a-102n)로부터 서버(106a-106n)로의 요청시 객체의 이름 또는 식별자를 식별할 수 있으며, 여기서 클라이언트가 객체를 요청한다. 다른 실시예에서, 캐시 관리자(232)는 클라이언트(102a-102n)의 요청시 또는 제2 캐시에 저장된 객체에 변화가 일어났음을 나타내거나 일어날 것임을 나타내는 서버(106a-106n)로부터의 응답시 제1 객체의 이름 또는 식별자를 식별할 수 있다. 다른 실시예들에서, 캐시 관리자(232)는 요청의 문자의 패턴이 캐시 내의 객체 또는 객체 그룹과 연관된 객체 결정인자들과 일치하는지를 판단한다. 일부 실시예들에서, 객체 결정인자는 현재 캐시에 저장되지 않은 객체에 대해 결정될 수 있다. 다른 실시예들에서, 객체 결정인자는 현재 무효로 마킹된 객체에 대해 결정될 수 있다. 다른 실시예들에서, 요청된 객체에 대한 객체 결정인자는 캐싱된 객체의 객체 결정인자와 연관된 것으로 결정된다. 또 다른 실시예에서, 통신에서 객체에 대한 제1 참조, 요청, 또는 응답시, 캐시 관리자(232)는 객체에 대한 객체 결정인자로서의 식별된 객체 결정인자를 설정한다.

객체 결정인자를 식별하기 위해 클라이언트 요청 또는 서버 응답과 같은 통신을 수신 및 분석함으로써, 캐시 관리자(232) 또는 어플라이언스(104)는 무효 식별된 객체 결정인자와 연관된 캐싱된 객체를 무효로서 마킹할지를 효과적으로 결정할 수 있다. 따라서, 단계 425에 따라, 객체 결정인자가 캐싱된 객체의 변화를 나타내는지를 판단한다. 일부 실시예들에서, 식별된 객체 결정인자는 객체를 변경, 수정 또는 발생하지 않는 통신의 부분일 수 있다. 다른 실시예들에서, 식별된 객체 결정인자는 객체 결정인자와 연관된 객체에 대해 변화가 일어났거나 날 것임 을 나타내는 통신의 부분이다. 예컨대, 통신은 동적으로 발생된 객체에 대한 겟(get) 요청 또는 하나 이상의 동적으로 발생된 객체들에 대해 사용된 데이터를 변화시키는 서브밋(submit) 요청일 수 있다. 일부 실시예들에서, 통신시 객체 결정인자의 존재는 하나 이상의 객체들에 대해 변화가 일어났거나 일어날 것임을 나타낸다. 다른 실시예에서, 통신에서 객체 결정인자와 함께 명령, 지령 또는 명시의 타입 또는 이름은 하나 이상의 객체들에 대해 변화가 일어났거나 일어날 것임 나타낸다. 또 다른 실시예에서, 명령, 지령 또는 지시의 파라미터 또는 변수의 존재, 값 또는 세팅은 객체 결정인자와 연관된 하나 이상의 객체들 상에서 변화가 일어났거나 일어날 것임 나타낸다.

다른 실시예들에서, 캐시 관리자(232)는 객체에서 변화가 일어났는지를 판단하기 위해 인터셉트된 통신 또는 객체 결정인자에 대해 해쉬 함수, 알고리즘, 또는 연산을 수행한다. 일부 실시예들에서, 해쉬 값은 객체에 대한 이전의 저장된 해쉬 값과 비교되고, 상이하면, 캐시 관리자(232)는 객체가 변한 것으로 인식한다. 또 다른 실시예에서, 객체에 대한 해쉬 값은 통신에서 또는 객체 결정인자에 포함될 수 있다. 일 실시예에서, 통신은 파라미터의 값 또는 세팅에 의해, 예컨대 불린 플래그로 객체가 변하였음을 나타낸다. 다른 실시예들에서, 보다 상세히 후술되는 바와 같이 엔티티 태그 제어 및 유효화 메커니즘은 객체를 식별하고 객체가 변하였는지를 판단하는데 사용될 수 있다.

변화가 지시되면, 단계 431에서, 객체 결정인자와 연관되거나 객체 결정 인자에 의해 식별된 객체는 무효로 마킹된다. 일부 실시예들에서, 인터셉트된 통신 에 의해 요청된 객체는 단계 431에 따라 무효 객체로서 마킹되고, 단계 440에 따라 시작 서버(106a-106n)로부터 검색된다. 그렇지 않으면, 다른 실시예들에서, 요청된 객체는 단계 450에 따라 캐시로부터 검색된다. 일 실시예에서, 무효로 마킹된 객체가 캐시로부터 플러싱될 것이다.

6. 객체 결정인자들에 기초한 객체들의 그룹의 무효화

본 발명의 상기 실시예는 클라이언트 요청시 객체 결정인자의 식별에 기초하여 캐시 관리자(232)에서 이전에 서빙된 객체를 무효화하는 경우를 설명한다. 이 일반적인 개념은 다른 실시예에서 하나 이상의 객체 결정인자들이 연관된 객체들의 그룹을 식별 또는 무효화하는데 이용된다. 이 실시예가 도 4D에 예시되어 있다.

도 4D에 기술된 상기 방법은 도 4C의 방법과 동일한 방식으로 시작된다. 단계 410은 객체들, 예컨대 시작 서버로부터 이전에 서빙된, 동적으로 발생된 객체들을 캐시에 저장하는 것을 포함한다. 일부 실시예들에서, 객체들 중 하나 이상은 캐싱 가능으로 식별되지 않는다. 단계 412에 따라 그리고 도 4B와 유사하게, 이전에 서빙된 객체들은 그룹들로 형성된다. 일 실시예에서 그리고 본 발명의 객체 결정인자 기술에 따라, 객체들의 그룹은 적어도 하나의 객체 결정인자와 연관되거나 그 결정 인자에 의해 식별된다. 보다 충분히 후술되는 바와 같이, 일부 실시예들에서, 그룹들과 객체 결정인자들의 연관성은 사용자 캐싱 정책, 예컨대 정책 엔진(236)에 의해 정의, 제어 또는 사용되는 정책의 성격 및 세부 사항에 좌우된다. 다른 실시예에서, 그룹의 하나 이상의 객체 결정인자는 그룹 내의 객체들의 하나 이상의 객체 결정인자들을 포함한다. 다른 실시예에서, 그룹의 객체 결정인자는 그룹 내의 객체들의 객체 결정인자들의 조합을 포함한다.

단계 414에 따라, 그룹의 레코드가 관련 객체 결정인자들(적용 가능한 경우)과 함께 유지된다. 이 단계은 도 4B에 예시된 단계 414와 유사하다. 일 실시예에서, 그룹의 레코드 및/또는 객체 결정인자들이 룩업 테이블에 유지된다. 다른 실시예들에서, 그룹의 레코드 및/또는 객체 결정인자들은 해쉬-테이블 포맷으로 유지된다. 해쉬-테이블은 알파벳 및 숫자 문장에서 넓은 갭을 가질 수 있는 불연속 키들을 효율적으로 저장하도록 설계될 수 있다. 다른 실시예에서, 인덱싱 시스템은 해쉬-테이블의 최상부에 구축될 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 그룹으로서의 객체들을 데이터베이스, 또는 메모리 내의 데이터 구조 또는 객체의 하나 이상의 객체 결정인자들과의 연관성을 유지한다. 다른 실시예들에서, 그룹 내의 각 객체의 플래그, 특성 또는 속성은 그룹의 이름 또는 식별자와 동일한 값, 이름 또는 식별자를 식별하거나 참조하는 값, 또는 그룹의 객체 결정인자에 할당 또는 설정된다. 일부 실시예들에서, 객체들의 그룹은 그룹을 유지하는 것으로 식별된 캐시 메모리의 일부에 배열, 배치 또는 위치된다. 다른 실시예에서, 하나 이상의 객체 결정인자들은 객체 그룹들과 연관되어 저장된다.

단계 421 및 423은 도 4C에 예시된 단계 421 및 423과 유사하다. 단계 421에 따라, 캐시 관리자(232) 또는 어플라이언스(104)는 클라이언트(102a-102n)와 서버(106a-106n) 간의 통신, 예컨대 이전에 서빙되어 캐시에 저장된 객체에 대한 클라이언트로부터의 요청을 인터셉트 또는 수신한다. 일 실시예에서, 캐시 관리 자(232)는 요청 클라이언트(102a-102n)로부터 서버(106a-106n)로의 요청을 인터셉트한다. 일부 실시예들에서, 요청은 캐시에 저장된 객체에 대해 행해진다. 다른 실시예들에서, 요청은 캐시에 저장된 객체의 변화를 야기하는, 예컨대 객체가 동적으로 발생되게 하는 서버(106a-106n)에 대한 명령, 명령 또는 지령이다. 다른 실시예에서, 캐시 관리자(232)는 캐시에 저장된 객체를 포함 또는 식별하는,서버(106a-106n)로부터 클라이언트(102a-102n)로의 응답을 인터셉트한다

단계 423에서, 객체 결정인자를 인터셉트된 통신에서 식별한다. 위에서 언급된 바와 같이, 객체 결정인자는 시작 서버(106a-106n)에서 변화가 일어났는지, 아니면 요청된 객체에서 일어날 것인지를 나타낸다. 그러나, 도 4D의 실시예에서, 객체 결정인자는 객체들의 그룹과 연관될 수 있다. 이는 특별한 객체 결정인자의 영향을 받을 수 있는 캐시에 저장된 모든 객체들 효율적인 무효화를 가능하게 한다. 일부 실시예들에서, 그룹 내의 객체의 객체 결정인자를 식별한다. 다른 실시예들에서는, 객체 그룹에 대해 객체 결정인자, 예컨대, 그룹 객체 결정인자를 식별한다. 다른 실시예에서는, 그룹 내의 하나 이상의 객체들의 객체 결정인자들의 조합을 식별한다.

따라서, 단계 427에 따라, 객체 결정인자가 이전에 서빙된 객체들의 그룹의 변화를 나타내는지를 판단한다. 일부 실시예들에서, 인터셉트된 통신에서 그룹의 객체 결정인자의 존재는 변화가 일어났거나 그룹 내의 객체들 중 하나 이상 또는 모두에서 일어날 것임을 나타낸다. 다른 실시예들에서, 인터셉트된 통신에서 명령, 지시 또는 지령의 이름 및 타입이 이러한 변화를 나타낸다. 또 다른 실시예에 서, 통신에서 임의 파라미터 또는 변수의 존재, 값 또는 세팅이 이러한 변화를 나타낼 수도 있다.

단계 427에서, 객체 결정인자는 그룹의 변화를 나타내면, 이전에 서빙된 객체들의 그룹은 단계 435에 따라 캐시에서 무효로 마킹된다. 일부 실시예들에서, 단계 440에 따라 그룹의 객체들 중 하나 이상 또는 모두가 요청되고 시작 서버(106a-106n)로부터 검색된다. 단계 427에서, 객체 결정인자가 그룹에서의 변화를 나타내지 않으면, 일부 실시예들에서, 인터셉트된 통신의 일부로서 요청되고 이전에 서빙되어 캐시에 저장된 객체들이 단계 450에 따라 캐시 관리자(232)로부터 검색된다. 일 실시예에서, 무효로 마킹된 어떤 객체 또는 객체들의 그룹이 캐시 관리자(232)에 의해 캐시로부터 플러싱될 수 있다.

7. 그룹 지정

캐시 관리자는 특별한 그룹에 포함된 어느 객체들을 얻을지를 구체적으로 지정할 수 있다. 객체가 캐시에 저장될 때마다, 관리자는 그 객체를 구조에 따라 구성되거나 내재하는 그룹들 중 한 그룹의 객체 멤버로 만들 수 있다. 구성된 그룹들은 관리자가 이전에 설정한 구성에 기초할 수 있고, 또는 대안으로 애플리케이션 행위, 및 객체 무효화에 관련된 다른 데이터에 기초할 수도 있다. 객체는 또한 그 구성된 그룹이 동적이면 내재하는 그룹의 일부일 수 있다. 내재하는 그룹 내의 객체들은 상당한 무효화 파라미터들의 값에 의해 그룹화된다.

매우 유연한 객체 그룹화를 허용함으로써, 캐시는 동적으로 발생된 콘텐트를 효과적으로 캐싱하는 것이 필요한 무효화의 유연성 및 조정(coordination)을 얻을 수 있다. 캐시는 특정 객체 그룹을 동시에 무효화할 수 있으며, 이에 따라 캐시는 동적으로 발생된 콘텐트를 무효화하라는 빈번한 요구에 더 응답적이게 된다. 캐시가 객체를 그룹에 할당하는 시간에, 그룹은 하나 이상의 객체 결정인자들을 연관시키기 위해 무효화 파라미터 및 히트 결정인자들을 포함해서 그 객체에 대한 많은 것을 결정한다.

소비자 자원 관리("CRM") 예에서, 캐시 관리자는 그룹들 각각을 미리 지정할 수 있다. 예컨대, 관리자는 판매 부서들의 각각을 이름으로 그룹화하기 위해 캐시를 구성한다. 따라서, 관리자는 자동차 부서, 오토바이 부서 등을 지정할 수 있고, 객체 결정인자는 캐시에 들어오는 요청에서 인식될 때마다, 캐시는 객체 결정인자를 통해 적절한 부서에 링크된 지정된 그룹에 저장되어 있는 모든 객체들을 무효화시킬 수 있다.

8. 규칙-기반 그룹화

대안으로, 캐시관리자는 캐시 어플라이언스가 특별한 그룹 또는 그룹들에 포함될 객체들을 결정하는 것을 가능하게 하는 규칙을 설정할 수 있다. 이러한 규칙-기반 그룹들은 캐시가 해당 그룹들을 생성하는데 이용한 상당한 객체 결정인자들에 객체를 링크하는 설정된 규칙들에 의한 그룹들의 지정에 의존할 수 있다. 이 접근법의 일 예는 캐시가 각 그룹에 놓을 객체들을 인식하는데 사용한 규칙으로 캐시를 구성하는 것을 포함할 수 있다.

CRM 예로 다시 돌아가서, 규칙은 애플리케이션 상에서 설정된 판매 부서의 각 하위 부분이 캐시에 의해 자신의 그룹으로 인식되어야 함을 언급할 수 있다. 이 방식으로, 그룹들은 캐시 관리자가 각 그룹을 구체적으로 식별해야할 필요 없이 생성될 수 있으나, 캐시가 해당 규칙에 기초하여 결정하는 것을 가능하게 한다. 이 기술은 그룹들을 지정하기 위해 보다 유연하고 종종 덜 노동 집약적인 방식을 생성한다. 캐시 관리자는 모든 판매 부서(즉, 판매\자동차 판매\오토바이 등)가 캐시에 의해 새로운 그룹을 발생해야 함을 언급한 규칙을 구성할 수 있다. 자동차 판매 부서로부터의 요청은 캐시를 통해 애플리케이션에 의해 처리 및 반환됨에 따라, 캐시는 각 판매 하위 그룹을 인식할 수 있고, 사전 구성된 규칙에 기초하여 자동으로 그룹을 생성할 수 있다.

상기 규칙은 타입 리포트/판매/자동차 또는 리포트/판매/오토바이 등의 객체에 대한 새로운 요청이 있을 때마다 캐시에 의해 구현될 수 있다. 이 프로세스는 캐시가 이들 하위 그룹을 인식하고 각 하위 그룹에 대해 객체 그룹을 설정함에 따라 오토바이 판매 부서 요청이 판매 부서, 오토바이 판매 부서 등의 하위 그룹임을 나타낼 때 반복될 수 있다. 알려진 무효화 요청이 이들 그룹 중 하나에 링크된 캐시에 대해 행해질 때, 또는 해당 객체 결정인자가 클라이언트 요청에서 식별되면(예컨대, 요청을 분석할 때 발견된 오토바이 판매 부서 판매/오토바이에 대한 판매 보고 부서), 캐시는 오토바이 판매 부서 그룹 내의 모든 캐싱된 객체들을 무효화하는 것으로 알게 된다.

이 방식에서, 캐시가 애플리케이션에 의해 서빙된 데이터에 대해 변화가 일 어났는지 아니면 일어날 것인지를 인식할 때(캐시에 의해 수신된 요청의 콘텐트가 애플리케이션에서의 변화를 트리거할 것임을 캐시가 인식하기 때문에 또는 외부 변화의 발생 때문에), 상기 기술은 어느 객체들이 그룹화 프로세스를 통해 무효화를 요구하는지를 캐시가 빠르고 간단하게 식별할 수 있게 한다. 이 방식으로, 캐시는 애플리케이션 또는 데이터베이스 상태의 변화 때문에 더 이상 새로운 것이 아닌 다수의 동적으로 발생된 객체들을 무효화할 수 있다.

동적으로 발생된 콘텐트를 캐시 메모리에 성공적으로 저장하고 캐시 메모리로부터 서빙할 수 있는 캐시의 능력은 또한, 최고의 캐싱 혜택을 제공하는 객체 세트를 일정 시간 기간에 걸쳐 결정하기 위해 요청 및 응답 트래픽의 패턴을 순서대로 검사하는 지능형 통계 엔진에 의해 향상될 수 있다. 상기 엔진은 캐시 어플라이언스 자체에 통합될 수도 있고, 동적 캐싱에 대한 적합성을 결정하기 위한 추가적인 조사를 위해 하위 세트의 객체들을 선택하는 발전적인 방법으로서 별개의 컴퓨터에서 구동될 수 있다

9. 객체 결정인자들의 다른 이용

상기한 바와 같이, 객체 결정인자들은 객체 결정인자가 연관된, 캐시에 저장된 이전에 서빙된 객체들의 그룹에 대한 변화가 시작 서버에서 일어났는지 아니면 일어날 것인지를 나타내는 데이터 구조일 수 있다. 객체 결정인자들은 요청에 삽입된 미리 정해진 스트링 값들에 기초하여 설정될 수 있다. 예컨대, 요청이 일정한 사용자 ID와 함께 들어오면, 사용자 ID는 포스트 또는 다른 요청이 일정한 사용 자 ID로부터 들어올 때마다 무효화되어야 하는 캐시 메모리 내의 객체 그룹에 링크될 수 있다. 객체 결정인자들에 대한 잠재적인 후보들은 또한, 객체를 처음에 서빙한 서버의 서비스 식별자를 이용하는 것을 포함할 수 있다. 서비스 식별자는 HTTP 요청에 존재하는 서비스 IP 주소, TCP 포트 및 서비스 식별자를 포함한다.

다른 잠재적인 객체 결정인자가 요청 URL(uniform resource locator)에 존재한다. 정적 객체들의 캐싱의 경우에, 요청 URL은 일반적으로 객체를 고유하게 식별하기에 충분하다. 그러나, 동적으로 발생된 콘텐트에 대한 요청의 경우, URL에 존재하는 정보는 캐싱된 객체를 식별하기에 충분하지 않을 수 있다. 그러므로 캐시는 HTTP 헤더, 쿠키 헤더에 또는 다른 커스텀 HTTP 헤더에 포함되는 객체 결정인자들을 찾으라는 요청에서 다른 정보를 조사한다. 캐시는 또한, URL 질의 스트링, POST 바디, 쿠키 헤더, 또는 어떤 다른 요청 또는 응답 헤더(이에 한정되지 않음)에 포함하는 클라이언트 요청 내의 여러 다른 장소에서 하위세트의 해당 파라미터 정보를 찾을 수도 있다.

객체 결정인자들에 대한 URL을 분석함에 있어서의 문제점은 URL 및 다른 헤더들은 캐시의 판단을 위해 관련된 것 외에 많은 정보를 포함할 수 있다는 것이다. 그러므로, 캐시는 적절한 객체 결정인자들을 식별할 수 있기 위해 아주 많은 정보를 통해 분석할 수 있다. 또한, 헤더 내의 데이터는 종종 임의로 배열되며, 이는 이러한 데이터를 HTTP 헤더에 배치하는 규격화된 방식이 없음을 의미하며, 그러므로 간단한 비교는 종종 이러한 스트링에서 해당 객체 결정인자들을 찾기에는 불충분하다.

특별한 객체 결정인자를 캐시 메모리에 저장된 해당 객체 또는 객체 그룹에 매칭시킬 미리 구성된 정책이 없는 경우, 캐시는 다른 실시예에서 여전히 이러한 결정을 행할 수 있다. 예컨대, 캐시는, 다른 객체 결정인자들이 이러한 요청에서 발견되어, 이러한 요청을 무효화되어야 하는 캐시 메모리에 저장된 특별한 객체들에 링크시키는데 이용될 수 있는지를 알아보기 위해 요청의 각종 양태들을 검사 및 분석할 수 있다. 대안으로, 캐시가 미리 정의된 발견적 방법에 기초하여 판단하건대 특별한 객체들 또는 객체들의 그룹에 의미 있게 링크될 수 있는 일정한 객체 결정인자들에 대한 요청을 캐시가 검사하는 것을 가능하게 할 수 있다. 예컨대, 특별한 사용자 ID와 연관된 카렌더의 갱신을 위해 캐시에 요청이 들어올 때, 본 발명의 실시예는 카렌더를 갱신하는 요청의 사용자 ID와 동일한 사용자 ID를 갖고 있고, 어느 특별한 날에 대한 사용자의 카렌더를 포함하는 모든 캐싱된 객체들이 무효화될 필요가 있을 것이라고 인식하도록 설정될 수 있다.

캐시는 URL 스템(Stem)에, URL에 존재하는 질의에, POST 바디에 또는 쿠키 헤더에 객체 결정인자들이 지정되지 않은 순서로 이름=값의 그룹 또는 유사한 쌍들로 존재하는 것으로 가정할 수 있다. 일 실시예에서, 질의는 이름=값 쌍들의 리스트로서 포매팅된 것으로 가정된다. 그러므로, 사용자는 중요한 파라미터 이름을 구성할 수 있다. 모든 캐싱된 객체는 제1 액세스 URL를 이용하여 키잉된다(keyed). URL은 /site/application/special/file.ext?p1=vI&p2=v2&p3=v3 처럼 보일 수 있다. /site/application/special/file.ext 쌍은 URL 스템이다. p1=vl&p2=v2&p3=v3 부분은 URL 질의이고 파라미터-값 쌍들을 포함한다. 이들 파라 미터-값 쌍은 POST 바디에 또는 쿠키 헤더에 존재할 수도 있다.

일 실시예에서, 사용자 또는 관리자는 pi 및 p2는 무효화 파라미터 또는 객체 결정인자일 것이라고 설정한다. 캐시는 그 후 매칭되는 pi 및 p2 값을 가진 객체들을 자동으로 그룹화할 것이다. 이 그룹화를 구현하는 한가지 방식은 pi 및 p2를 데이터베이스 테이블 내의 주요 키들, 즉 유효화 상태를 결정하기 위해 캐시가 참조하는 방법을 알고 있는 테이블 내의 고유하게 식별가능한 객체들에 맵핑시키는 것이다. 이들 데이터베이스 테이블 내에 있는 것을 갱신하기 위하여, 캐시에 저장된 데이터는 더 이상 유효하지 않다는 사실을 반영하기 위해, 캐시는 pi 및 p2에 대한 새로운 값을 지정할 것이며, 캐시는 이러한 콘텐트를 서빙하게 되는 다음번에 이러한 새로운 값을 인식할 때, 메모리에 저장된 링크된 객체들을 무효화하는 것으로 알게 된다. 갱신 요청이 있을 때 상기한 요청을 만나면 캐시는 원점 데이터가 변화할 것임을 알고 있기 때문에, 매칭된 pi 및 p2 값으로 그룹을 무효화해야 하는 것을 알게 되며, 이에 따라 pi 및 p2 객체 결정인자들에 관련된 모든 객체들이 영향을 받는다.

관리자가 객체 결정인자들로서 요청에 삽입된 사전 구성된 특정 파라미터를 가지고 있지 않은 더욱 복잡한 경우를 처리하기 위해, 캐시는 객체 그룹들을 무효화할 때를 식별하는 것을 돕기 위해 요청으로부터 해당 객체 결정인자들을 추출하기 위해 사용자-구성된 정책들을 전개할 수 있다. 결정인자 스트링은 캐시 내에 저장된 객체 그룹을 찾아내고 이러한 객체들을 무효화하는데 이용될 수 있다. 이들 객체 결정인자는 상당한 파라미터 값들의 리스트들을 발생하기 위해 캐시를 구 성하는데 이용될 수 있다. 들어오는 기록-요청이 상당한 파라미터들에 대한 매칭 값을 가지고 있으면, 파라미터이름에 연결된 객체들이 무효화되어야 한다. 대안으로, 사용자는 요청으로부터 객체 결정인자 스트링을 추출할 수 있는 정책 프레임워크 행위를 지정할 수 있다. 객체 결정인자 스트링은 기록-요청으로부터 추출되고 매칭 결정인자 스트링을 가진 모든 객체들은 무효화된다. 이 대안적인 접근법에서는, 요청이 캐시에 도달하고, 캐시는 요청 스트링이 무효화 정책과 일치하는지를 판단을 한다. 무효화 정책은 콘텐트 그룹이 무효화되어야 하는 객체들을 지정한다.

대안으로, 캐시는 클라이언트 요청에 존재할 수 있는 다른 사용자 정보를 이용할 수 있다. 위에서 언급된 바와 같이, 인증 및 허가 통합은 사용자 정보에 대한 캐시 액세스를 가능하게 한다. 사용자 ID 또는 그룹 ID는 캐싱된 객체들의 해당 그룹이 사용자 또는 사용자 그룹과 링크된 경우에 결정인자들 중 하나일 수 있다. 사용자 정보는 종종 중요한 객체 결정인자이지만, 사용자 정보는 종종 HTTP 요청에 존재하지 않을 수 있다. 본 발명의 다른 실시예에서, 본 발명의 동적 캐싱 양태들은 출원인의 다른 특허 출원들과 조합될 수 있다. 이를 달성하기 위해, 출원인의 위에서 참조한 함께 계류중인 특허 출원 제 11/169,002("통합 캐싱 특허")를 참조한다. 이 출원은 일정한 종류의 인증, 액세스 제어 및 감사(AAA) 인프라구조를 수행할 수 있는 능력을 포함하는 다양한 다른 네트워킹 소자들과 캐시를 통합하기 위한 시스템 및 방법을 기술한다. 따라서, 애플리케이션들에 의해 발생된 데이터에 따른 보안의 레벨은 캐시로부터 대신 서빙되는 데이터에 적용된다. 이 기 술은 애플리케이션들이 캐싱될 수 없는 민감한 액세스 제어 정보를 캐싱하는 것을 가능하게 한다.

이 접근법은, TTP 요청에 식별가능 사용자 정보를 포함하고 있지 않으나 통합 캐싱 특허에 기술된 AAA 접근법을 통해 식별할 수 있는 사용자들을, 캐시가 식별하는 것을 가능하게 한다. 이러한 접근법은 캐시가 AAA 처리로부터 공유될 수 있는 허가 상태 정보를 검사함으로써 특별한 요청에 대해 해당 사용자를 식별하는 것을 가능하게 한다. 다른 실시예에서, 통합은 캐시에 저장된 정보에의 보안 정책들의 적용이 허가받지 않은 사용자들이 캐시에 저장된 정보를 액세스하는 것을 방지하는 것을 가능하게 한다.

이 접근법은 또한, 동적으로 발생된 데이터의 상당한 부분이 이러한 데이터를 요청한 클라이언트가 캐시가 해당 요청 클라이언트로부터의 해당 요청에 응답할 수 있기 전에 허가 및 인증될 것을 요구한다는 사실에 의해 부과된 도전을 처리한다. 캐시는 애플리케이션들이 액세스-제어 객체들을 캐싱할 수 있도록 인증된 사용자들에 의해 행해지는 요청을 허가하는 능력을 가지고 있어야 하며, 이러한 동적 캐싱 기술을 인증 및 허가 정보와 통합함으로써, 이 보안이 달성될 수 있다. 사용자 ID 또는 그룹 ID는 객체들이 사용자 또는 사용자 그룹에 대해 개성화된 경우 객체 결정인자들 중 하나 일 것이다. 따라서, 애플리케이션들에 의해 발생된 데이터에 제공된 보안 레벨이 마찬가지로 캐싱된 정보에 적용된다. 이 기술은 애플리케이션들이 캐싱 불가한 민감한 액세스 제어 정보를 캐싱하는 것을 가능하게 한다.

마지막으로, 하루 중의 시간, 원점에서의 데이터베이스 상태 등과 같은 다른 정보가 요청으로부터 분석될 수 있고, 캐시에 저장된 객체들이 아직 유효한지를 판단하기 위해 객체 결정인자들로서 이용될 수 있다. 캐시는 이러한 외부 변수에 민감하도록 구성된 객체들의 그룹에서 적절한 만료 행위를 구성함으로써 이 상황을 대비할 수 있다.

또한 동적 콘텐트에 대한 요청들이 캐시에 의해 분석 및 해석되어야 한다는 사실에 의해 제시된 도전을 처리하기 위해, 본 발명의 일 실시예에 따른 캐시는 파라미터들이 캐시에 대한 해당 객체 결정인자들로 간주되는 것으로 제한할 수 있다. 이 방식으로, 이러한 요청들을 적용가능 애플리케이션 서버에 전송하기보다는 캐시로부터의 객체들을 서빙하는 성공률을 개선될 수 있다. 일 예로, 클라이언트로부터의 요청 질의는 도시(city) 및 주(state) 파라미터를 포함할 수 있다. 그러나, 캐시는 도시 값에 관계없이 주어진 상태의 모든 클라이언트로부터 들어오는 것으로 질의가 알려준 클라이언트들로부터의 요청에 대해 응답이 서빙될 수 있음을 인식하기 위해 캐시가 콘텐트를 저장하고 있는 애플리케이션에 대한 요건과 일치하도록 구성될 수 있다. 이 목적을 위해, 도시 파라미터는 관련이 없고 캐시가 이 사실을 인식할 수 있다. 대안적인 실시예는 도시 파라미터가 주 파라미터에 대해 지정된 것에 관계없이 일치하면 캐시로부터 서빙될 수 있도록 캐시를 구성하는 것을 포함한다.

정리하면, 캐시는 일반화된 파라미터화 객체 매칭을 구현한다. 이 접근법에서, 캐시는 객체 결정인자들로서 유용하고 특별한 객체에 링크되는 요청에서 정보 의 서브세트를 인식하도록 구성되어, 이러한 객체 결정인자들이 인식되면, 캐시는 객체 또는 객체들의 그룹이 새롭고 캐시로부터 서빙될 수 있는지를 추정할 때 존재(또는 역으로 이러한 결정인자들의 부재)를 이용할 수 있다. 캐시는 요청된 데이터가 새로운지를 결정하기 위해 구성된 파라미터에 대해 요청이 체크하게 될 때마다 참조하는 테이블을 유지하고, 이는 또한 캐시가 해당 데이터를 캐시 메모리에 저장된 적절한 객체와 매칭시키는 것을 가능하게 한다.

10. 구체화 번호(Incarnation Number)

또 다른 실시예에서, 캐시는 한 그룹의 객체들을 무효화하기 위해 구체화 번호s를 이용할 수 있다. 원점에서의 상태 변화 때문에 그룹 내의 객체 상태를 한 번에 변화시킬 필요가 있는 경우, 구체화 번호s는 이 무효화를 행하는 간단한 기술을 제공한다. 반면에 각 객체를 식별하고 상태를 개별적으로 변화시키는 것은 캐시에 저장된 데이터의 새로움을 보장하는데 비효율적인 접근법이며, 구체화 번호s의 이용은 객체 그룹을 무효화하는데 훨씬 더 간단하고 효과적인 접근법을 가능하게 한다. 본 실시예는 각 객체가 그룹을 나타내는 데이터 구조를 가리키는 방법에 대해 설명하나, 서버는 상기 그룹의 데이터 구조의 상태를 변화시키는 명령을 전송하는데에 만 필요하다. 캐싱된 객체에 대한 후속 요청이 클라이언트로부터 도달할 때, 캐시는 먼저 상태가 변화되었는지를 해결해야 한다. 이와 같이 하기 위해, 상태가 그룹에 대해 변화되었는지를 참조하기 위해 데이터 구조를 룩업한다.

데이터 구조를 효과적으로 구현하기 위해, 캐시는 상태 변화에 대해 룩업할 지를 결정할 수 있어야 한다. 그러나, 캐시는 그룹에서 상태 변화를 이미 보았는지의 여부를 결정할 수 있어야 한다. 이는 구체화 번호s가 도움이 되는 경우이다. 캐시는 동적으로 발생된 객체들을 콘텐트 그룹들에 연관시킨다. 이들 콘텐트 그룹들 각각은 데이터 구조에 포함된 특별한 인덱스 값 또는 "구체화 번호"를 가지고 해쉬 테이블 룩업 프로세스를 통해 표현될 수 있다. 그 후, 캐시가 상태 변화를 야기하는 것으로 인식한 클라이언트 요청을 수신할 때마다, 클라이언트는 해당 파라미터에 대한 클라이언트 요청을 파싱하고, 인식된 객체 결정인자들에 기초하여 해쉬 룩업을 수행하고, 데이터 구조에서 인덱스 또는 구체화 번호를 증가시킨다. 지정된 그룹 내에 저장된 객체가 클라이언트에 의해 요청될 때마다, 캐시는 객체에 대해 해쉬 알고리즘을 수행하여 이러한 콘텐트 그룹에 대한 데이터 구조에서의 원래 저장된 값과 비교한다. 상기 저장된 값이 이러한 객체에 대해 캐시에 의해 계산된 수와 동일하면, 캐시는 콘텐트는 새롭고 요청자에게 서빙될 수 있음을 안다. 캐시가 이러한 객체에 대해 계산된 현재의 구체화 번호와 데이터 구조에서 이러한 콘텐트 그룹에 대해 저장된 수 간의 불일치를 검출한 경우에, 캐시는 상기 저장된 객체는 더 이상 새로운 객체가 아님을 안다. 다음에, 캐시는 상기 저장된 객체를 무효화하고 요청을 애플리케이션 서버에 전송한다. 상기 응답이 돌아오면, 캐시 어플라이언스는 새로운 응답을 캐시 메모리에 저장하고 이러한 응답을 다시 새로운 데이터 구조에 링크시킬 것이다. 그 후, 캐시가 그 그룹에서 객체에 대한 요청을 수신할 때마다, 캐시는 비교를 행할 수 있고, 데이터 구조에 다른 변화가 없다면, 캐시는 새롭게 저장된 객체를 서빙할 수 있다.

이 방식으로 객체들의 그룹의 무효화를 이용함으로써, 캐시는 매우 빠르게 무효화할 수 있고, 소요 시간은 무효화된 객체들의 수에 관계없이 일정하다. 이보다 빠르고 보다 효율적인 무효화 프로세스를 통해, 본 발명의 기술들은 캐시는 동적으로 발생된 객체들을 보다 효과적으로 처리하는 것을 가능하게 한다. 접근법은 애플리케이션 앞에 있는 캐시 어플라이언스가 이러한 데이터의 급속한 변화 때문에 무효 또는 진부한 콘텐트를 서빙하지 않고 동적으로 발생된 객체들을 보다 적극적으로 저장 및 서빙하는 것을 가능하게 한다. 실시예는 캐시가 빈번하게 또는 예측 불가능하게 변화하는 데이터를 서빙할 수 있게 함으로써, 캐시 성능을 향상시킨다. 캐시는 사용자 명령들을 이용하여 그리고 또한 각종 웹 트래픽을 검사 및 그룹화함으로써 캐시 메모리에 저장된 객체들 및 객체 그룹을 무효화할 수 있다 .

11. 플래시 캐시 및 플래시 크라우드.

본 발명의 다른 실시예는 캐싱 가능하지 않은, 동적으로 발생된 객체들을 매우 빠르게 변화시키기 위해 캐시 히트 레이트를 증가시킬 수 있는 기술을 포함할 수도 있다. 캐시 관리자(232)가 특별한 객체에 대한 요청을 제1 클라이언트로부터 수신하면, 캐시 관리자(232)는, 상기 제1 요청시 이러한 객체가 아직 저장되어있을 수 없으므로 처리를 위해, 그 요청을 시작 서버(106a-106n)로 전송한다. 응답 객체가 발생되어 캐시 관리자(232)를 통해 요청 클라이언트로 보내짐에 따라, 캐시 관리자(232)는 객체의 카피를 자동으로 저장한다. 매우 빠르게 변화하는 객체의 경우, 본 발명과 대조적인 전통적인 캐시는, 콘텐트는 새로운 것이 아니어서 캐시 기억에 유효하지 않은 것으로 가정되기 때문에, 모든 응답을 처리를 위해 시작 서버(106a-106n)로 전달한다.

일 양태에서, 본 발명은 캐시 관리자(232) 또는 어플라이언스(104)가 객체의 제1 요청자에 대한 응답을 전송하거나 전송 대기하는 프로세스에 있는 시간 동안에 캐시 관리자(232)에 의해 수신된 객체에 대한 추가적인 요청을 처리하기 위한 "플래시 캐시" 기술에 관한 것이다. 이제 도 5를 참조하면, 본 발명의 방법 500은 본 발명의 플래시 캐시 기술을 나타낸다. 개략적으로 그리고 도 1 및 도 2를 참조하면, 단계 510에서, 본 발명의 캐시 관리자(232)는 제1 클라이언트, 예컨대 도 1에 예시된 클라이언트(102a)에 의해 요청된 객체에 대한 응답을 시작 서버(106a-106n)로부터 수신한다. 객체는 시작 서버들(106a-106n) 중 하나에 의해 발생되는 동적으로 발생된 객체를 구비할 수 있고, 및 시작 서버(106a-106n)로부터 응답은 동적으로 발생된 객체를 포함할 수 있다. 단계 515에서, 캐시 관리자(232)는 예컨대 네트워크 스택, 예컨대, 장치(104)의 TCP/IP 스택을 통해 제1 클라이언트로의 응답의 전송을 요청하고, 단계 520에서, 상기 응답은 전송 대기 중에 버퍼에 저장 또는 홀딩될 수 있다. 예컨대, 장치(104)는 저속 접속되거나 낮은 대역폭의 클라이언트(102a)로의 통신을 조절할 수 있으며, 그러므로, 장치(104)는 상기 응답을 나타내는 네트워크 패킷들을 큐잉한다.

단계 525에서, 제1 클라이언트(102a)의 응답이 버퍼 내에서 또는 전송 프로세스에서 전송되기를 기다리고 있는 동안 및/또는 제1 클라이언트(102a)로의 응답의 전송 완료 전에, 캐시 관리자(232)는 제2 클라이언트(102b)로부터 객체에 대한 제2 요청을 수신한다. 단계 530에서, 캐시 관리자(232)는 객체가 버퍼에 현재 있는 것으로 판단하고 제2 요청에 응답하여 버퍼로부터의 객체를 제2 클라이언트(102b)에 제공한다. 일 실시예에서, 장치가 단일 TCP/IP 스택을 사용함에 따라, 동일한 객체가 제1 클라이언트(102a) 및 제2 클라이언트(102b)로의 전송을 위해 제공될 수 있다. 단계 535에서, 제1 응답은 제1 클라이언트(102a)에 전송되고, 응답은 제2 클라이언트(102b)로 전송된다. 단계 540에서, 상기 제1 클라이언트(102b)의 응답은 버퍼로부터 제거된다.

상세히 설명하면, 단계 510에서, 장치(104)는 예컨대 캐시 관리자(232)에 의해, 객체, 예컨대 동적으로 발생된 객체에 대한 제1 클라이언트(102a)로부터의 요청에 대한 응답을 시작 서버(106a-106n)로부터 인터셉트 또는 수신한다. 일 실시예에서, 동적으로 발생된 객체는 예컨대 시작 서버(106a-106n)에 의해 캐싱 불가능한 것으로 식별되거나, 캐싱 가능으로 식별되지 않는다. 일부 실시예들에서, 캐시 관리자(232)는 제1 클라이언트(102a)로부터 요청을 수신하고 그 요청을 시작 서버(106a-106n)로 전송한다. 일 실시예에서, 캐시 관리자(232)는 요청을 시작 서버(106a-106n)에 전송하기 전에 요청된 객체에 대한 캐시 관리자(232)를 체크한다. 일부 경우들에서, 캐시 관리자(232)는 객체가 무효인지 아니면 만료되었는지를 판단한다. 다른 경우들에서, 캐시 관리자(232)는 객체가 저장되어 있지 않은지 아니면 캐시 관리자(232)에 이용 가능한 지를 판단한다, 예컨대, 객체는 예컨대 플러싱되어 있어야 하며, 이는 객체가 시작 서버(106a-106n)로부터 처음으로 요청된 것일 수 있다. 일부 실시예들에서, 상기 응답은 객체를 포함하고, 다른 실시예들에 서는, 상기 응답은 상태, 예컨대 객체에 관한 장애 또는 에러 메시지를 나타낸다.

단계 515에서, 제1 클라이언트(102a)에 의한 요청에 대한 응답은 제1 클라이언트(102a)에의 전송을 위해 제공된다. 일부 실시예들에서, 장치(104)는 상기 응답을 수신하고, 상기 응답을 클라이언트(102a)에 전송하도록 패킷 처리 엔진(240)에 요청한다. 다른 실시예들에서, 캐시 관리자(232)는 상기 응답을 수신하고 상기 응답을 클라이언트(102a)에 전송하기 위해 패킷 처리 엔진(240)에 요청한다. 일 실시예에서, 장치(104)는 네트워크 패킷들을 수신하여 클라이언트(102a-102n)로 전송하기 위한 하나의 네트워크 스택을 구비한다. 일부 실시예들에서, 네트워크 스택들은 TCP/IP 스택을 구비한다. 다른 실시예들에서, 장치(104)는 하나 이상의 클라이언트(102a-102n)와 연관되거나 그 클라이언트에 의해 사용되는 다중 네트워크 스택들을 포함할 수 있다. 네트워크 스택들 또는 스택들은 당업자가 인식 및 이해하는 바와 같이 커널(204), 네트워크 포트들(226) 및/또는 패킷 처리 엔진(240)과 연관된다.

단계 520에서, 상기 응답을 단계 515에서 요청된 제1 클라이언트(102a)에 전송하는 동안에, 장치(104)는 버퍼에 상기 응답을 큐잉, 홀딩 또는 저장한다. 일부 실시예들에서, 버퍼는 네트워크 스택, 예컨대 TCP/IP 스택의 일부이다. 예컨대, 버퍼는 TCP/IP 스택에서 또는 TCP/IP 스택에 의해 또는 네트워크 스택의 어느 부분을 처리하는 네트워크 드라이버, 필터 또는 다른 네트워크 관련 소프트웨어에 의해 사용되는 데이터 구조를 구비할 수 있다. 다른 실시예들에서, 버퍼는 네트워크 포트(226)의 일부이다. 추가적인 실시예들에서, 버퍼는 패킷 처리 엔진(240)의 일부 이고, 또는 또 다른 실시예들에서, 커널은 버퍼를 구비한다. 버퍼는 장치(105)의 어느 부분에 위치된 메모리 또는 기억 소자일 수 있다. 많은 실시예들에서, 상기 응답은 하나 이상의 네트워크 패킷들, 예컨대 TCP/IP 프로토콜 기반 패킷들로서 버퍼에 큐잉, 유지 또는 저장될 수 있다. 일 실시예에서, 상기 응답은 본 발명에 의해 사용되는 버퍼를 제공하는 하나 이상의 데이터 구조들에 홀딩된다. 당업자는 인식 및 이해하는 바와 같이, 상기 응답은 어떤 적합한 형태로 버퍼에 큐잉, 홀딩 또는 저장될 수 있다.

또한, 상기 응답은 임의의 또는 미리 결정된 또는 내재된(implicit) 또는 명백한(explicit) 시간 기간 동안 어떤 적합한 수단 및/또는 메커니즘을 사용하여 버퍼에 저장 또는 큐잉될 수 있다. 일 실시예에서, 상기 응답은, 네트워크 패킷이 전송 레이트, 패킷 큐잉 레이트, 네트워크 트래픽 및 폭주, 또는 어떤 다른 네트워크 특징에 기초하여 장치(104)에 의해 전송되기를 기다리고 예컨대 패킷 처리 엔진(240) 및/또는 네트워크 포트들(226)을 통해 장치(104)에 의해 결정될 수 있으므로 버퍼에 저장된다. 다른 실시예에서, 상기 응답은 결정된 시간 기간 동안 버퍼에 홀딩된다. 일부 실시예들에서, 장치(104)는 클라이언트의 네트워크 접속(들)의 대역폭, 타입의 접속 등과 같은 특징, 또는 클라이언트(102a)의 특징에 기초하여 네트워크 패킷들을 큐잉, 관리하고 클라이언트(102a)에 전송할 수 있다. 예컨대, 시작 서버(106a-106n)에의 장치의 접속보다 느린 장치(104)에의 접속을 가진 클라이언트(102a)의 경우, 장치(104)는 클라이언트(102a)의 원하는 성능 또는 행위 또는 클라이언트(102a)의 네트워크 접속을 제공하기 위해 네트워크 패킷들의 클라 이언트(102a)의 전송을 조절 또는 관리할 수 있다. 이와 같이, 장치(104)는 상기 응답 큐잉 또는 버퍼 관리 로직, 기능, 규칙 또는 동작에 따라 원하는 시간 기간 동안 버퍼 내에 상기 응답을 큐잉 또는 홀딩한다.

단계 525에서, 제1 클라이언트(102a)의 응답이 버퍼에 홀딩되어 있거나 전송되고 있는 동안에 또는 상기 응답을 TCP/IP 스택의 버퍼와 같은 제1 클라이언트(102a)로 전송 완료하기 전에, 장치(104)는 예컨대 캐시 관리자(232)를 통해, 제1 요청에 대해 캐시 관리자(232)에 의해 얻어진 객체에 대한 제2 요청을 제2 클라이언트(102b)로부터 인터셉트하거나 수신한다. 즉, 일 실시예에서, 제2 클라이언트(102b)에 의해 요청된 객체는 전송 대기하고 있는 버퍼에 저장된다. 일부 실시예들에서, 장치(104)는 제1 클라이언트(102a)에 의해 요청된 동일한 객체에 대한 다수의 요청을 다수의 클라이언트(102b-102n)로부터 수신하고, 상기 객체는 제1 클라이언트(102a)로의 전송을 위해 현재 버퍼에 홀딩되어 있거나 현재 제1 클라이언트(102a)로 전송되고 있는 것이다. 일부 실시예들에서, 캐시 관리자(232)는 제2 요청이 예컨대 객체 결정인자들을 이용하여 여기서 설명되는 기술들과 같은 어떤 적합한 수단 및/또는 메커니즘을 사용하여 제1 요청과 동일한 객체를 요청하고 있는 것으로 판단한다. 일부 실시예들에서, 어플라이언스(104) 또는 캐시 관리자(232)는 임의 타입 및 형태의 큐잉 메커니즘을 이용하여 제2 요청 및 추가적인 요청을 큐에 큐잉한다. 이와 같이, 일 실시예에서, 클라이언트(102a-102n)는 어플라이언스(104) 또는 캐시 관리자(232)가 서버(106a-106n)를 위해 요청을 큐잉 및 응답함에 따라 요청을 다시 제출할 필요가 없다. 다른 실시예에서, 어플라이언 스(104) 또는 캐시 관리자(232)는 요청을 서버(106a-106n)로 제출하지 않고 요청을 투명하게 클라이언트(102a-102n)에 큐잉 및 응답한다. 어플라이언스(104) 또는 캐시 관리자(232)는 본 발명의 기술들의 이용에 응답될 클라이언트(102a-102n)로부터의 요청들을 큐잉하기 위해 메모리 내의 메커니즘, 예컨대 큐, 객체, 또는 데이터 구조를 이용할 수 있다.

단계 530에서, 장치(104)는 제2 클라이언트(102b)에 의해 요청된 객체가 상기 응답 버퍼에 저장되어 있는지 아니면 제1 클라이언트(102a)에 현재 전송되는 응답에 있는지를 판단한다. 일부 실시예들에서, 캐시 관리자(232)는 객체가 버퍼에 저장된 것으로 판단한다. 일부 경우에서, 캐시 관리자(232)는 먼저 객체에 대해 캐시 메모리 또는 기억 장치를 체크하고, 객체에 대해 버퍼를 체크한다. 다른 경우들에서, 버퍼는 캐시 관리자(232)에 의해 탐색 또는 관리될 캐싱된 객체들에 대한 기억 위치로 고려될 수 있다. 다른 실시예들에서, 캐시 관리자(232)는 객체가 버퍼에 있는지를 체크하기 위해 패킷 처리 엔진(240)을 요청한다. 추가적인 실시예들에서, 캐시 관리자(232)는 커널(204)의 애플리케이션 프로그래밍 인터페이스(API)를 통해 객체가 버퍼 내에 있는지를 판단한다. 일부 경우들에서, 캐시 관리자(232)는 객체가 버퍼 내에 있는지를 판단하기 위해 네트워크 스택의 부분을 다루거나 처리하는 드라이버, 네트워크 핸들러, 필터, 또는 다른 소프트웨어와 인터페이싱한다.

또한 단계 530에서, 본 발명은 버퍼에 저장되거나, 단계 525에서 제2 클라이언트(102b)로부터의 제2 요청에 대한 응답으로 사용되는 제1 클라이언트(102a)에 대한 응답으로서 전송되는 객체를 제공한다. 일부 실시예들에서, 장치(104)는 예컨대 패킷 처리 엔진(104)을 통해 버퍼의 일부 및 네트워크 스택의 관련 데이터 구조들을 사용하여 제2 요청에 대한 응답을 형성한다. 일 실시예에서, 객체는 일단 버퍼에 예컨대 단일 네트워크 스택 구성으로 저장되고, 각각 제1 클라이언트(102a) 및 제2 클라이언트(102b)에 전송될 네트워크 패킷들을 형성하는데 사용된다. 다른 실시예들에서, 버퍼로부터의 객체의 카피는 제2 요청에 대한 응답을 형성하는데 사용된다. 다른 실시예들에서, 객체는 제2 클라이언트(102b)에 대한 제2 요청에 대한 응답을 형성하기 위해 제1 네트워크 스택으로부터 제2 네트워크 스택으로 제공된다. 제1 클라이언트(102a)의 응답은 버퍼 내에 유지될 수 있고, 버퍼 내의 응답의 일부 또는 모두가 제2 클라이언트(102b)에 응답을 제공하기 위해 사용될 수 있다. 일 실시예에서, 버퍼에 저장된 제1 클라이언트의 응답은 제2 클라이언트(102b)에 응답하여 수정 없이 이용될 수 있다. 다른 실시예에서, 버퍼 내의 제1 클라이언트(102a)의 응답에 저장된 객체를 나타내는 데이터는 제2 클라이언트(102b)에 대한 응답을 제공하기 위해 수정된다.

본 발명의 방법 500의 단계 535에서, 제1 클라이언트(102a)에 대한 제1 응답은 장치(104)로부터 전송되고, 제2 클라이언트(102b)의 제2 요청에 대한 제2 응답은 장치(104)로부터 전송된다. 제1 클라이언트(102a) 및 제2 클라이언트(102b)에 대한 응답은 동일한 네트워크 스택(267) 또는 상이한 네트워크 스택을 사용하여 상호 간에 시간 간격을 두고 장치(104)로부터 임의 순서로 전송될 수 있다. 일부 실시예들에서, 제2 클라이언트(102b)에 대한 상기 응답은 전송 대기 중인 버퍼에 큐 잉, 홀딩 또는 저장된다. 이와 같이, 동일한 객체에 대한 추가적인 요청은 버퍼에 저장되어 있고 아직 전송, 플러싱, 제거되지 않거나 이용 가능하지 않은 제1 응답 또는 제2 응답을 통해 제공될 수도 있다.

단계 540에서, 제1 클라이언트(102a)의 응답은 버퍼로부터 플러싱되거나 제거된다. 일부 실시예들에서, 제2 클라이언트(102b)의 응답이 버퍼에 저장된 경우, 상기 제2 클라이언트의 응답도 제거된다. 다른 실시예들에서, 제2 클라이언트의 응답은 버퍼에 남아 있을 수 있고, 방법 500의 단계 525 내지 535는 객체에 대한 제3 요청을 제3 클라이언트로부터 수신하면서 제2 클라이언트 응답을 이용하여 다시 실시된다.

다른 양태에서, 본 발명은 서버가 제1 요청자에 대한 응답 객체를 처리 및 반환하고 있는 시간 동안에 어플라이언스(104) 또는 캐시 관리자(232)가 동일한 객체에 대한 추가적인 요청, 예컨대, 거의 동시적인 요청을 수신하는 상황을 처리하기 위한 "플래시 크라우드(flash crowd)" 기술에 관한 것이다. 일단 이러한 거의 동시적인 요청들 모두가 캐시에 의해 응답되면, 객체는 캐시 메모리로부터 즉시 플러싱되며, 추가적인 만료 시간 또는 애플리케이션 또는 관리자에 의한 무효화 행위는 없다. 본 발명의 이 기술은 데이터가 캐싱 불가능으로 고려되지 않는 객체들에 대해 짧은 시간 동안 캐싱 및 서빙되는 것을 가능하게 한다. 이 접근법은 빠르게 변화하는 데이터, 예컨대, 실시간 주식 시세 또는 빠르게 진행되는 뉴스 스토리를 많은 동시 사용자들에 서빙하는 애플리케이션들을 크게 향상시킨다.

도 6은 제1 요청에 응답하여 동일한 콘텐트를 수신함에 따라 상기 콘텐트를 클라이언트 요청자 각각에 서빙하기 위해 본 발명의 캐시에 의해 행해지는 단계들을 나타낸 방법 600을 기술한다. 방법 600의 단계 610에서, 캐시 관리자(232) 또는 어플라이언스(104)는 시작 서버(106a-106n)로부터의 객체, 예컨대 동적으로 발생된 객체에 대한 제1 요청을 제1 클라이언트(102a)로부터 수신한다. 단계 615에서, 캐시는 제1 요청을 시작 서버(106a-106n)로 전송한다. 제1 요청에 대한 응답을 기다리면서 또는 제1 클라이언트(102a)의 제1 요청에 응답하기 전에, 단계 620에서, 캐시는 객체에 대한 제2 클라이언트(102b)로부터 제2 요청을 수신한다. 일부 실시예들에서, 캐시는 제2 요청을 시작 서버로 전송하지 않고 대신에 제2 요청을 큐잉한다. 단계 625에서, 캐시는 시작 서버로부터 제1 요청에 대한 응답을 수신하고, 단계 630에서, 제1 요청에 응답하여 수신 응답 및/또는 상기 응답으로부터의 객체를 제1 클라이언트(102a)에 전송하고 제2 요청에 응답하여 제2 클라이언트(102b)에 전송한다. 단계 635에서, 캐시는 수신 응답 및/또는 상기 응답으로부터의 객체를 제1 클라이언트(102a) 또는 제2 클라이언트(102b)에 전송 완료하기 전에 객체에 대한 제3 클라이언트(102c)로부터 추가적인 제3 요청을 수신할 수 있다. 단계 640에서, 캐시는 또한 수신 응답 및/또는 상기 응답으로부터의 객체를 제3 클라이언트(102c)에 전송한다. 요청에 대한 응답시, 캐시는 단계 645에서 예컨대, 만료 시간 또는 애플리케이션, 시작 서버, 또는 관리자에 의한 무효화 행위 없이 캐시 메모리로부터 객체를 플러싱한다.

도 1 및 도 2를 참조하여 상세히 설명하면, 본 발명의 방법 600의 단계 610에서, 어플라이언스(104)의 캐시 관리자(232)는 일 실시예에서, 클라이언트(102a) 와 시작 서버(예컨대 106a) 간의 통신 중 어떤 시점에 객체, 예컨대 동적으로 발생된 객체에 대한 요청(102a-102n)을 클라이언트, 예컨대 도 1의 클라이언트(102a)로부터 인터셉트 또는 수신할 수 있다. 일 실시예에서, 제1 클라이언트(102a)로부터의 요청은 제1 클라이언트(102a)가 처음으로 객체를 요청한 것일 수 있다. 일 예에서, 클라이언트(102a)는 시작 서버(106a)에의 접속시 제1 시간 동안 객체를 요청할 수 있다. 다른 예에서, 캐시 관리자(232)는 클라이언트(102a) 또는 다른 클라이언트(102a-102n)를 위해 시작 서버(106a)로부터의 객체에 미리 캐싱하거나 요청하지 않을 수도 있다. 다른 실시예들에서, 클라이언트(102a)로부터의 요청은 이전에 요청된 객체에 대한 후속 요청일 수 있다. 또 다른 실시예들에서, 캐시 관리자(232)는 단계 610에서 클라이언트(102a)에 의해 요청된 객체를 미리 캐싱해 두고 있을 수 있다. 이와 같이, 도 6에 예시된 본 발명의 기술들은 객체가 현재 캐싱 되는지, 이전에 캐싱 되었는지, 아니면 캐싱 되지 않았는지에 관계없이 클라이언트(102a-102n)와 시작 서버들(106a-106B) 간의 통신 코스 중에 어느 시점에서 실시될 수 있다.

단계 615에서, 캐시 관리자(232)는 클라이언트(102a)로부터의 요청을 시작 서버(106a)에 전송한다. 일 실시예에서, 캐시 관리자(232)는 객체가 캐시관리자(232)에 저장되어 있는지를 체크하지 않고 요청을 시작 서버에 전송한다. 일부 실시예들에서, 캐시 관리자(232)는 먼저 클라이언트(102a)에 의해 요청된 객체가 캐시 관리자(232)로부터 이용 가능한지를 체크하고, 이용 가능하지 않으면, 요청을 시작 서버(106a)에 전송한다. 다른 실시예들에서, 캐시 관리자(232)는 객체가 캐 시에 저장되어 있으나 무효인지 아니면 갱신될 필요가 있는지, 또는 막 무효로 되었는지 아니면 짧게 갱신될 필요가 있는지를 체크한다. 다른 실시예에서, 캐시 관리자(232)는 캐시에 저장된 동적으로 발생된 객체가 시작 서버(106a-160N)로부터 동적으로 다시 발생되어 서빙되어야 하는 것으로 판단한다. 이와 같이, 캐시 관리자(232)가 객체가 서버(106a-106n)로부터 요청되어야 하는 것으로 판단하면, 캐시 관리자(232)는 클라이언트(102a)로부터의 요청을 시작 서버(106a-106n)로 전송한다. 일 실시예에서, 캐시 관리자(232)는 제1 클라이언트(102a)로부터 수신된 동일 또는 원래 요청을 시작 서버(106a)로 전송한다. 다른 실시예에서, 캐시 관리자(232)는 제1 클라이언트(102a)에 의해 요청되거나 요청에서 식별된 객체에 대한, 캐시 관리자(232)에 의해 형성된 요청을 전송한다.

시작 서버(106a-160N)로부터의 제1 클라이언트(102a)의 요청에 대한 응답을 기다리면서 및/또는 제1 클라이언트(102a)의 요청에 응답하기 전에, 단계 620에서 캐시 관리자(232)는 단계 610에서 제1 클라이언트(102a)의 제1 요청에 의해 식별, 연관 또는 요청된 객체에 대한 하나 이상의 추가적인 요청을 인터셉트 또는 수신할 수 있다. 예컨대, 일 실시예에서, 캐시 관리자(232)는 제1 요청에 응답하여 시작 서버(106a)에 의해 동적으로 발생될 수 있는 객체에 대한 제2 요청을 제2 클라이언트(102b)로부터 수신한다. 일 실시예에서, 어플라이언스(104) 또는 캐시 관리자(232)는 임의 타입 및 형태의 큐잉 메커니즘을 이용하여 큐에 제2 요청 및 추가적인 요청을 큐잉한다. 일부 실시예들에서, 객체에 대한 제2 및/또는 추가적인 요청이 캐시 관리자(232)에 의해 거의 동시에 일어나거나 수신될 수 있다. 다른 실 시예들에서, 제2 및/또는 추가적인 요청은 제1 요청의 수신과 시작 서버(106a)로부터의 제1 요청에 대한 응답의 수신 사이의 어느 시점에서 캐시 관리자(232)에 의해 인터셉트되거나 수신될 수 있다. 또 다른 실시예에서, 제2 및/또는 추가적인 요청은 제1 요청의 수신과 제1 요청에 대한 응답의 클라이언트(102a)에의 제공 사이의 임의 시점에 캐시 관리자(232)에 의해 수신될 수 있다.

일 실시예에서, 제1 요청에 응답하기 전에는, 캐시 관리자(232)는 제2 클라이언트(102b)로부터의 객체에 대한 제2 요청 및/또는 어떤 다른 클라이언트(102c-102n)로부터의 객체들에 대한 다른 추가적인 요청을 전송하지 않는다. 일 실시예에서, 캐시 관리자(232)는 단계 625에서 제1 요청에 대한 응답을 수신할 때까지 예컨대, 어플라이언스(104)에 제2 및 추가적인 요청을 큐잉 또는 유지한다. 이와 같이, 제2 클라이언트(102b)에 투명한 캐시 관리자(232)는 제2 클라이언트의 요청을 전송하지 않는다. 그러나, 일부 실시예들에서, 요청이 예컨대 시작 서버(106a-106n)에 의해 처리된 것으로 제2 클라이언트(102b)에 나타난다.

일부 실시예들에서, 제2 클라이언트(102a)로부터의 제2 요청은 단계 610에서 제1 요청과 동일한 객체를 요청할 수 있으나, 다른 객체 또는 다른 정보, 정적, 동적 정보 등에 대한 추가적인 요청을 포함할 수도 있다. 예컨대, 제2 클라이언트(102b)의 요청은 다수의 요청을 포함할 수 있다. 이들 실시예에서, 캐시 관리자(232)는 제1 클라이언트(102a)의 제1 요청과 함께 이미 요청된 객체에 관련된 요청의 부분을 식별할 수 있고, 제1 요청에 대한 응답이 수신될 때까지 상기 식별된 부분을 처리하지 않을 수 있다. 제2 클라이언트(102b)로부터의 요청의 다른 부분 들의 경우, 캐시 관리자(232)는 이들 다른 요청들을 어떤 적합한 방식으로, 예컨대 여기서 설명되는 본 발명의 기술들에 의해 처리할 수 있다. 예컨대, 제2 요청은 제2 객체에 대한 요청을 포함할 수 있고, 이 경우 캐시 관리자(232)는 시작 서버(102a-20B)로부터의 제2 객체를 요청하거나 캐시 관리자(232)로부터 제2 객체를 얻는다.

단계 625에서, 본 발명의 방법 600은 단계 615에서 시작 서버(106a)로 전송된 제1 요청에 대한 응답을 수신한다. 일부 실시예들에서, 상기 응답은 객체, 예컨대 서버(106a-106n)에 의해 동적으로 발생된 객체를 포함한다. 다른 실시예들에서, 상기 응답은 캐시 관리자(232)에 의해 페치되거나 얻어질 객체의 위치에 대한 포인터를 포함한다. 다른 실시예들에서, 상기 응답은 에러 메시지를 나타내거나 요청된 객체가 제공될 수 없음을 나타낼 수 있다. 일 실시예에서, 캐시 관리자(232)는 상기 응답이 요청에 대해 적합 또는 적절한지를 판단하기 위해 수신된 응답을 대응 요청과 비교한다. 다른 실시예들에서, 캐시 관리자(232)는 상기 응답의 콘텐트, 예컨대 동적으로 발생된 객체를 얻고, 제1 클라이언트(102a)에 전달되기를 원하는 응답을 생성, 수정 또는 제공한다.

단계 630에서, 본 발명의 캐시 관리자(232)는 제1 요청 및 동일한 객체에 대한 제2 또는 추가적인 요청에 응답하기 위해 제1 요청에 대해 수신된 응답 및/또는 응답으로부터의 객체를 이용한다. 일 실시예에서, 캐시 관리자(232)는 제1 요청에 응답하여 수신 응답을 제1 클라이언트(102a)에 전송하고, 제2 요청에 응답하여 수신 응답을 제2 클라이언트(102b)에 전송한다. 다른 실시예에서, 캐시 관리자(232) 는 수신 응답을 제1 클라이언트(102a)에 전송하나, 제2 요청에 응답하여 수신 응답을 수정하여 제2 클라이언트(102b)에 전송한다. 예컨대, 캐시 관리자(232)는 제2 요청에 대응하는 세션 정보 또는 다른 정보를 포함하도록 제2 클라이언트(102b)에 대한 응답을 수정할 수 있다. 다른 실시예들에서, 캐시 관리자(232)는 수신된 응답으로부터 요청된 객체를 얻고, 제1 요청 및 제2 요청에 대응하고 객체를 포함하는 응답, 예컨대 제1 응답 및 제2 응답을 생성, 수정 또는 제공하며, 대응 응답을 제1 클라이언트(102a) 및 제2 클라이언트(102b)로 전송한다. 이와 같이, 캐시 관리자(232)는 객체에 대한 클라이언트(102a-102b)로부터의 요청에 응답할 때 시작 서버(106a-106n)로부터 제1 요청에 대해 수신된 응답의 전부 또는 일부를 이용할 수 있다.

일부 실시예들에서, 캐시 관리자(232)는 서버(106a)로부터 제1 요청에 대한 응답을 수신한 후 그리고 제1 클라이언트(102a), 제2 클라이언트(102b) 또는 단계 625에서 객체를 요청한 어떤 다른 클라이언트(102a-102c)로의 응답의 전송을 완료하기 전에, 단계 635에서 다른 클라이언트(102c-102n)로부터 객체에 대한 추가적인 요청들을 인터셉트 또는 수신할 수 있다. 예컨대, 캐시 관리자(232)는 제3 클라이언트(102C)로부터 객체에 대한 제3 요청을 수신할 수 있다. 이들 실시예에서, 캐시 관리자(232)는 이들 추가적인 요청에 응답하기 위해 단계 630에서 시작 서버(106a-106n)로부터의 제1 요청에 대해 수신되어 클라이언트(102a 및/또는 102b)로 전달되는 응답의 모두 또는 일부를 이용할 수 있다. 다른 실시예에서, 캐시 관리자(232)는 제1 클라이언트(102a) 및 제2 클라이언트(102b)로의 응답의 전송을 완 료하였을 수도 있으나, 메모리 내에 상기 응답들을 여전히 가지고 있을 수도 있고 또는 제1 요청을 통해 제공된 객체로 제3클라이언트(102c)의 제3 요청에 응답하는데 이용할 수 있다. 이와 같이, 단계 640에서, 본 발명의 캐시 관리자(232)는 시작 서버로부터의 객체를 다시 요청하지 않고 및/또는 요청된 객체를 캐시에 저장하지 않고 제3 요청 또는 다른 추가적인 요청에 응답할 수 있다.

일부 실시예들에서, 어플라이언스(104) 또는 캐시 관리자(232)는 제2 요청, 제3 요청 또는 추가적인 요청을 큐에 큐잉한다. 이와 같이, 일 실시예에서, 클라이언트(102a-102n)는 어플라이언스(104) 또는 캐시 관리자(232)가 서버(106a-106n)를 위해 요청을 큐잉 및 응답함에 따라 요청을 다시 제출할 필요가 없다. 다른 실시예에서, 어플라이언스(104) 또는 캐시 관리자(232)는 요청을 서버(106a-106n)로 제출하지 않고 요청을 투명하게 클라이언트(102a-102n)에 큐잉 및 응답한다. 어플라이언스(104) 또는 캐시 관리자(232)는 본 발명의 기술들의 이용에 응답되도록 클라이언트(102a-102n)로부터의 요청을 큐잉하기 위해 메모리에서 큐, 객체, 또는 데이터 구조와 같은 메커니즘을 이용할 수 있다. 또한, 어플라이언스(102) 또는 캐시 관리자(232)는 임의 순서로, 그리고 반드시 그런 것은 아니지만 수신된 순서로 또는 큐로부터의 선입선출 방식으로 클라이언트 요청에 응답할 수 있다.

단계 645에서, 캐시 관리자(232)는 시작 서버(106a)로부터의 제1 요청에 대한 수신 응답, 클라이언트의 요청에 대한 응답, 및/또는 캐시 관리자(232)로부터의 요청들에 의해 요청된 객체를 플러싱한다. 일 실시예에서, 캐시 관리자(232)는 최종 응답의 전송 완료시, 예컨대 일 실시예에서 단계 630에서 또는 다른 실시예에 서는 단계 640에서 캐시로부터 응답 및/또는 객체를 즉시 플러싱한다. 일부 실시예들에서, 캐시 관리자(232)는 예컨대 만료 시간에 따라 미리 결정된 시간 기간 동안 객체를 유지한다. 다른 실시예들에서, 캐시 관리자(232)는 시작 서버(106a-160N)가 객체를 무효화시킬 때까지 객체를 캐시에 유지시킨다. 또 다른 실시예에서, 객체는 메모리 또는 기억 장치에 기록이 행해지거나 메모리 또는 기억 장치가 캐시 관리자(232)에 의해 다른 용도로 사용될 때까지 메모리 또는 기억 장치에 남아 있다.

본 발명의 방법 500 및 600의 기술들은 일반적으로 다수의 클라이언트로부터의 단일 객체에 대한 요청에 관해 위에서 설명되었으나, 당업자는 본 발명의 플래시 캐시 및 플래시 크라우드 처리 기술들은 단일 요청 또는 순차적으로, 동시에, 또는 거의 동시에 일어날 수 있는 다수의 클라이언트의 일련의 요청에서 다수의 객체 요청들을 처리하는데 사용될 수 있음을 인식 및 이해할 것이다. 이와 같이, 방법 500 및 600을 실시하는 다수의 예들이 네트워크 환경(200)에서 캐시 관리자(232) 또는 어플라이언스(104)의 동작 과정 동안에 여러 빈도 및 여러 시간에 실행할 수 있다. 또한, 각 클라이언트로부터의 각 요청 또는 일련의 요청들은 상이한 객체 세트들을 요청할 수 있고, 하나 이상의 객체들의 공통 세트가 하나 이상의 클라이언트들 사이에서 요청된다.

예컨대 본 발명의 플래시 크라우드 기술들에 따라, 제1 클라이언트는 제1 객체 및 제2 객체를 요청할 수 있고, 제2 클라이언트는 제2 객체 및 제3 객체를 요청할 수 있으며, 제3 클라이언트는 제1 객체 및 제3 객체를 요청할 수 있다. 일부 실시예들에서, 본 발명의 캐시는 다수의 클라이언트 사이에서 나타나는 다수의 요청의 각각의 객체에 대해 객체를 요청하기 위해 다중화 및/또는 역다중화 기술들을 이용하며, 따라서 대응 응답을 각 클라이언트에 제공한다. 상기 예에서 또한, 캐시는 제1 클라이언트 및 제3 클라이언트에 대해 시작 서버로부터 제1 객체를, 제1 클라이언트 및 제2 클라이언트에 대해 제2 객체를, 및 제2 클라이언트 및 제3 클라이언트에 대해 제3 객체를 얻을 수 있다. 일부 실시예들에서, 클라이언트에 대한 하나 이상의 요청에 대한 모든 객체들이 캐시에 의해 수신될 때, 캐시는 대응 응답 또는 응답들을 클라이언트에 전송한다. 다른 실시예들에서, 캐시는 캐시에 의한 객체 수신시 각 객체로 클라이언트에 응답할 수 있다.

마찬가지로, 본 발명의 방법 500의 플래시 캐시 기술에 따라, 어플라이언스의 버퍼는 객체들에 대한 추가적인 요청이 어플라이언스에 의해 수신되는 동안 전송 대기 중인 다수의 객체를 포함할 수 있다. 일 실시예에서, 본 발명의 어플라이언스는 단일 TCP/IP 스택을 이용하여, 이 스택으로부터 다수의 버퍼들이 전송 과정 중에 다수의 객체와 연관되어 그 객체들을 일시적으로 저장한다. 이와 같이, 버퍼 내의 제1 객체는 제1 객체에 대한 제1 클라이언트 및 제2 클라이언트로부터의 요청에 응답하는데 사용될 수 있고, 버퍼 내의 제2 객체는 제2 객체에 대한 제3 클라이언트 및 제4 클라이언트로부터의 요청에 응답하거나, 제2 객체에 대한 제1 클라이언트 또는 제2 클라이언트로부터의 요청에 응답하는데 사용될 수 있다.

또한, 본 발명의 플래시 캐시 및 플래시 크라우드 기술들은 당업자가 인식 및 이해하는 바와 같이 함께 또는 조합되어 실시될 수 있다. 예컨대, 본 발명의 어플라이언스는 플래시 캐시 기술을 통해 버퍼로부터의 객체에 대한 추가적인 요청에 대한 응답을 제공할 수 있으나, 버퍼 내의 객체가 무효인지 아니면 시작 서버로부터 요청될 필요가 있는지를 판단한다. 이때, 어플라이언스는 시작 서버로부터의 객체를 요청함으로써 플래시 크라우드 기술로 전환할 수 있다. 어플라이언스는 시작 서버의 응답을 기다리면서 어플라이언스에서 수신되어 규킹된 객체에 대한 추가적인 요청에 응답하기 위해 시작 서버로부터 요청된 객체를 이용한다

12. 이태그(Etag) 삽입

다른 양태에서, 본 발명은 캐시가 후속 요청에서 히트를 체크할 수 있도록 클라이언트에 응답하여 정보, 예컨대 객체에 대한 엔티티 태그 및 캐시 제어 정보를 삽입함으로써 캐시 히트 레이트를 증가시키는 기술에 관한 것이다. 본 발명은 시작 서버가 객체를 캐싱 가능으로 식별하지 못할 때 동적으로 발생된 객체를 클라이언트에 대해 캐싱 가능으로 식별하는 기술을 제공한다. 일부 실시예들에서, 예컨대 객체들에 대한 HTTP 요청 및 응답을 처리하는 실시예에서, 본 발명의 기술들은 엔티티 태그, 또는 "이태그"를 상기 응답에 삽입하여, 캐시 제어 시작 서버로부터의 엔티티 태그 및/또는 캐시 제어 정보 없이 제공되는 객체들에 대한 캐시 제어를 제공한다. 당업자에게 알려진 HTTP 프로토콜을 간단히 참조하면, "이태그"는 요청된 변형, 예컨대 객체에 대한 엔티티 태그의 현재의 값을 제공하는 HTTP 기반 메시지의 이태그 헤더 필드이며, 동일한 자원으로부터의 다른 엔티티들과의 비교에 이용될 수 있다. 이태그는 HTTP 프로토콜에서 유효화 메커니즘을 제공한다. 또 한, HTTP 기반 메시지는 요청/응답 메시지 또는 통신 체인을 따라 캐싱 메커니즘에 대한 지령을 지정하기 위해 캐시-제어 헤더 필드를 포함할 수 있다. 캐시-제어 지령들은 원하는 캐싱 행위를 지정한다.

이제 도 7A 및 도 7B, 도 1 및 도 2를 참조하면, 본 발명의 "이태그" 기술들을 실시하는 실시예를 위한 단계들이 도시되어 있다. 도 7A의 개요에서, 본 발명의 방법 700은 단계 710에서 클라이언트(102a-102n)에 의해 요청된 객체, 예컨대 시작 서버(106a-106n)로부터 서빙되어 어플라이언스(104)의 캐시 관리자(232)에 의해 수신된 객체를 가진 응답을 수신한다. 단계 715에서, 캐시 관리자(232)는 상기 응답으로부터의 객체가 태그 엔티티 제어하에 있는지 아니면 엔티티 태그를 가지고 있는지를 판단한다. 객체가 엔티티 태그를 가지고 있지 않으면, 단계 720에서, 캐시 관리자(232)는 객체에 대한 엔티티 태그를 발생한다. 단계 725에서, 캐시 관리자(232)는 캐시 발생된 엔티티 태그를 포함하는 엔티티 제어 정보를 제공하기 위해 상기 응답을 수정한다. 단계 730에서, 캐시 관리자(232)는 엔티티 태그 정보를 가진 객체를 캐시 관리자(232)에 저장한다. 단계 735에서, 캐시 관리자(232)는 수정된 응답으로 객체를 요청한 클라이언트(102a-102n)에 응답한다. 이와 같이, 클라이언트(102a-102n)는 클라이언트(102a-102n)에 투명한 방식으로 캐시 관리자(232)로부터 엔티티 태그 제어 객체를 수신하며, 클라이언트(102a-102n)는 시작 서버(106a-106n)가 객체에 엔티티 태그 정보를 제공하지 않았다는 사실을 알지 못한다.

상세히 설명하면, 본 발명의 단계 710에서, 캐시 관리자(232)는 시작 서 버(106a-106n)로부터 객체에 대한 클라이언트(102a-102n)의 요청에 대한 응답을 수신한다. 일부 실시예들에서, 상기 응답은 클라이언트(102a-102n)로부터 서버(106a-106n)로 또는 클라이언트(102a-102n) 대신에 캐시 관리자(232)로부터 서버(106a-106n)로 전송된 요청으로부터 수신될 수 있다. 일 실시예에서, 캐시 관리자(232)는 매칭 및/또는 유효 객체에 대해 캐시 관리자(232)를 체크한 후 클라이언트(102a-102n)로부터 서버(106a-106n)로 요청을 전송한다. 다른 실시예에서, 캐시 관리자(232)는 도 6을 참조하여 설명되는 본 발명의 플래싱 크라우드 기술을 실시하는 동안에 서버(106a-106n)로부터의 객체를 요청한다.

방법 700의 단계 715에서, 캐시 관리자(232)는 단계 710에서 응답으로 수신된 객체가 엔티티 태그 제어하에 있는지 아니면 엔티티 태그를 가지고 있는지를 판단한다. 일부 실시예들에서, 캐시 관리자(232)는 상기 응답을 제공하는 하나 이상의 패킷들의 필드, 헤더, 데이터, 또는 다른 정보를 조사, 검사, 체크 또는 판독한다. 당업자가 인식 및 이해하는 바와 같이, 조사 또는 판독할 패킷 또는 패킷들의 부분은 상기 응답에 사용된 하나 이상의 프로토콜의 타입에 좌우된다. 일 실시예에서, 캐시 관리자(232)는 상기 응답 패킷의 엔티티 태그 부분이 손실되거나 비어있거나 또는 제공되지 않은 것으로 판단한다. 다른 실시예에서, 캐시 관리자(232)는 상기 응답 패킷의 엔티티 태그 부분은 오류가 있거나 무효이거나 캐시 관리자(232) 및/또는 클라이언트(102a-102B)에 의해 사용 가능하지 않은 것으로 판단한다. 일부 실시예들에서, 캐시 관리자(232)는 상기 응답이 엔티티 태그를 가지고 있거나 엔티티 제어하에 있는 것으로 판단하나, 캐시 관리자(232)가 원하는 타 입, 형태 또는 방식이 아닌 것으로 판단한다. 엔티티 태그 외에 또는 엔티티 태그 대신에, 캐시 관리자(232)는 엔티티 태그와 유사한 방식으로, 원하는 캐시-제어 정보가 상기 응답에 존재하는지를 판단한다. 다른 실시예들에서, 캐시 관리자(232)는 정책 엔진(236)을 통해 객체는 엔티티 태그 및/또는 캐시 제어하에 있는지를 결정할 수 있다. 이와 같이, 일부 실시예들에서, 어플라이언스(104)가 정책 엔진(236)을 통해 객체가 엔티티 태그 또는 캐시 제어하에 있어서는 안 된다고 판단하면 캐시 관리자(232)는 본 발명의 이태그 기술들, 예컨대 단계 720 내지 725를 계속 수행하지 않을 수 있다.

단계 720에서, 캐시 관리자(232)는 수신된 응답의 객체에 대한 원하는 엔티티 태그 및 캐시 제어 정보를 발생한다. 이태그는 임의 타입 및/또는 형태의 엔티티 태그 표현을 포함할 수 있고 하나 이상의 문자에서 숫자, 알파벳, 문자를 포함할 수 있다. HTTP의 실시예에서, 이태그는 스트링 또는 인용된 스트링을 포함할 수 있고, 또한 프리픽스를 포함할 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 이태그 카운터를 순차적으로 또는 원하는 증분으로 증가시키는 엔티티 헤더, 또는 이태그, 카운터를 사용한다. 일부 실시예들에서, 이태그 카운터는 캐시 관리자(232)가 이태그를 발생하는 모든 객체들을 커버한다. 다른 실시예들에서, 캐시 관리자(232)는 객체 또는 객체 그룹과 각각 연관되거나 특정된 다수의 이태그 카운터들을 가질 수 있다.

일 실시예에서, 이태그는 객체과 관련된 UID(universal identifier) 또는 GUID(global universal identifier)를 구비할 수 있다. 다른 실시예에서, 이태그 는 이전에 설명한 바와 같이 구체화 번호를 구비할 수 있다. 일부 실시예들에서, 캐시 관리자(232)는 어플라이언스(104) 상에서 구동되는 애플리케이션, 프로그램, 또는 다른 형태의 실행가능 명령들로부터 또는 다른 실시예들에서는 네트워크를 통해 어플라이언스(104)에 의해 액세스 가능한 다른 시스템 또는 장치로부터 이태그를 얻는다. 또한 실시예들에서, 캐시 관리자(232)는 객체에 대한 원하는 고유한 이태그를 발생하기 위해 어떤 적합한 알고리즘, 비즈니스 규칙 또는 로직을 이용할 수 있다. 일 실시예에서, 어플라이언스(104)는 캐시 관리자(232)에 대한 객체들의 이태그를 발생 및 유지하기 위한 데이터베이스, 파일, 또는 다른 조직된 기억 소자를 구비한다.

방법 700의 단계 725에서, 캐시 관리자(232)는 원하는 엔티티 태그 및/또는 캐시 제어 정보, 예컨대 단계 720에서 캐시에 의해 발생된 엔티티 태그를 포함하도록 시작 서버(106a-106n)로부터의 응답을 수정한다. 일 실시예에서, 캐시 관리자(232)는 프로토콜, 예컨대 HTTP 프로토콜의 엔티티 태그 헤더를 통해 엔티티 태그 정보를 삽입한다. 다른 실시예에서, 캐시 관리자(232)는 원하는 엔티티 태그를 포함하도록 상기 응답에서의 엔티티 태그 헤더 필드를 수정한다. 또 다른 실시예에서, 캐시 관리자(232)는 상기 응답 내의 엔티티 태그 필드를 캐시 관리자(232)에 의해 사용될 엔티티 태그 필드로 대체한다. 다른 실시예들에서, 상기 응답을 클라이언트(102a-102n)에 전달하기 위해 엔티티 태그 정보가 네트워크 패킷 또는 패킷들의 어느 부분에 삽입, 수정 또는 배치된다.

또한, 단계 725에서, 캐시 관리자(232)는 원하는 캐시-제어 정보를 헤더, 프 로토콜의 필드, 또는 상기 응답을 전달하기 위한 네트워크 패킷들의 다른 부분에 삽입, 수정 또는 배치할 수 있다. 캐시-제어 정보는 어떤 적합한 수단 및/또는 메커니즘에 의해 캐시 관리자(232)에 의해 발생될 수 있다. 일 실시예에서, 캐시-제어 정보는 장치(104)의 정책 엔진(236) 내에 구성되거나 정책 엔진(236)을 통해 얻어진다. 다른 실시예에서, 캐시 관리자(232)는 캐시 관리자(232)의 알고리즘, 비즈니스 규칙, 또는 로직으로부터 원하는 캐시 제어 정보를 결정한다. 일부 실시예들에서, 캐시-제어 정보는 클라이언트(102a-102n)와 어플라이언스(104) 또는 캐시 관리자(232) 간의 네트워크 및 캐싱 성능의 히스토리에 기초할 수 있다.

본 발명의 방법 700의 단계 730에서, 캐시 관리자(232)는 캐시 관리자(232)에 어떤 적합한 또는 원하는 방식으로 객체를 가진 발생된 엔티티 태그를 저장한다. 일부 실시예들에서, 엔티티 태그는 상기 저장된 객체의 일부에 포함되거나 그 일부로 만들어진다. 다른 실시예들에서, 엔티티 태그는 별도로 저장되나 객체와 연관된다. 다른 실시예에서, 엔티티 태그 및 객체는 데이터베이스, 링크된 리스트, 룩업 테이블, 또는 당업자에게 알려진 바와 같이 한 엔티티를 다른 엔티티와 연관시키기 위한 다른 메커니즘을 통해 연관된다. 또한, 일부 실시예들에서 객체 및/또는 엔티티 태그가 제공된 캐시-제어 정보는 캐시 관리자(232)에 객체와 연관되어 저장될 수도 있다.

단계 735에서, 캐시 관리자(232)는 어플라이언스(104)가 수정된 응답을 클라이언트(106a-106n)에 전송할 수 있도록 한다. 예컨대, 캐시 관리자(232)는 패킷 처리 엔진(240)에게 수정된 응답을 클라이언트(102a-102n)에 전송할 것을 요청한 다. 이와 같이, 클라이언트(102a-102n)는, 클라이언트(102a-102n)에게 알려지지 않은 시작 서버(106a-106n)가 일 실시예에서 이러한 정보를 발생하지 않거나 캐시 관리자(232가 서버(106a-106n)에 의해 발생된 이러한 정보를 변화시키더라도, 엔티티 태그 및 캐시 제어 정보를 가진 객체를 수신한다. 본 발명의 이태그 기술은 모든 객체가 확인자(validator), 즉, 이태그를 갖는 것 또는 캐시 관리자(232)에 의해 제어되거나 캐시 관리자(232)가 원하는 이태그를 갖는 것을 보장할 수 있다. 객체가 확인자 또는 원하는 확인자를 가지고 있지 않으면, 캐시 관리자(232)는 자신의 이태그를 삽입한다. 이들 이태그 확인자는 도 7B를 참조하여 설명되는 바와 같이 객체에 대한 반복 요청시 완전 응답의 서빙을 피할 수 있다.

도 7B는 객체가 수정되었는지를 클라이언트(102a-102n)가 체크하기 위해 엔티티 태그를 사용하기 위한 본 발명의 방법 750을 나타낸다. 이와 같이, 클라이언트(102a-102n)는 클라이언트(102a-102n) 상에 객체를 캐싱할 수 있고, 객체가 변하였는지를 캐시 관리자(232) 또는 시작 서버(106a-106n)로 체크할 수 있다. 방법 750의 개요에서, 단계 775에서, 캐시 관리자(232)는 객체의 엔티티 태그를 체크하기 위해 클라이언트(102a-102n)로부터 요청을 수신한다. 단계 760에서, 캐시는 클라이언트(102a-102n)의 요청으로부터 수신된 엔티티 태그를 캐시에 저장된 객체의 엔티티 태그와 비교하고, 단계 765에서, 캐시 관리자(232)는 클라이언트로부터의 엔티티 태그가 캐시 내의 객체의 엔티티와 일치하는지를 판단한다. 엔티티 태그들이 일치하지 않으면, 단계 770에서 캐시 관리자(232)는 객체에 대한 현재의 엔티티 태그를 제공하는 응답으로 클라이언트(102a-102n)에 응답한다. 엔티티 태그들이 일치하면, 단계 775에서 캐시 관리자(232)는 객체가 수정되었음을 나타내는 응답으로 클라이언트(102a-102n)에 응답한다.

상세히 설명하면, 단계 755에서, 캐시 관리자(232)는 임의 타입 및/또는 형태의 통신에 의해 객체의 엔티티 태그를 체크 또는 유효화하기 위해 클라이언트(102a-102n)로부터 요청을 수신할 수 있다. 일 실시예에서, 요청은 클라이언트(102a-102n)에 의해 제공되는 엔티티 태그 스트링 값을 포함하는 If-Match 또는 If-None-Match 요청 헤더 필드를 가진 HTTP 메시지를 포함한다. 예컨대, 클라이언트(102a-102n)는 클라이언트 캐시 내에 있거나 클라이언트(102a-102n) 상에서 이용 가능한 객체의 카피를 가질 수 있다. 클라이언트(102a-102n)는 객체가 현재인지를 판단 또는 유효화하기 위해 요청에 있는 객체의 클라이언트의 카피의 엔티티 태그를 이용한다.

단계 760에서, 캐시 관리자(232)는 캐시 관리자(232)가 클라이언트(102a-102n)와는 다른 객체 버전을 가지고 있는지를 판단하기 위해 클라이언트(102a-102B)로부터 수신된 엔티티 태그 값을 객체에 대한 엔티티 태그와 비교한다. 캐시 관리자(232)는 클라이언트(102a-102n)로부터의 엔티티 태그 값을 캐싱된 객체의 엔티티 태그 값과 비교하기 위해 어떤 적합한 수단 및/또는 메커니즘을 사용할 수 있다. 일 실시예에서, 캐시 관리자(232)는 요청으로부터의 이태그 값과 캐시에 객체와 함께 저장된 이태그에 대해 바이트 비교를 수행한다. 다른 실시예에서, 캐시 관리자(232)는 객체가 수정되었는지를 판단하기 위해 엔티티 태그 및/또는 캐시 객체에 대해 해쉬 알고리즘을 수행 및 이용한다. 다른 실시예들에서, 캐시 관리 자(232)는 서버(106a-106n)로부터 객체를 요청하고, 객체가 수정되었는지를 판단하기 위해 수신된 객체를 캐싱된 객체와 비교한다.

단계 765에서, 클라이언트(102a-102n)로부터의 엔티티 태그가 캐시 관리자(232)에 객체와 함께 저장된 엔티티 태그와 일치하지 않으면, 단계 770에서 캐시 관리자(232)는 엔티티 태그들이 일치하지 않음 또는 객체가 수정되었음을 나타내는 응답을 클라이언트에 전송한다. 일 실시예에서, 캐시 관리자(232)는 응답을 클라이언트(102a-102n)에 전송하여 객체에 대한 새로운 엔티티 태그 값을 제공한다. 다른 실시예에서, 캐시 관리자(232)는 응답을 클라이언트(102a-102n)에 전송하여, 새로운 객체 버전, 또는 수정된 객체, 예컨대 캐시 관리자(232)에 저장된 새로운 엔티티 태그를 가진 수정된 객체를 제공한다. 단계 765에서, 클라이언트(102a-102n)로부터의 엔티티 태그가 캐시 관리자(232)에 객체와 함께 저장된 엔티티 태그와 일치하면, 단계 775에서, 캐시 관리자(232)는 응답을 클라이언트에 전송하여 엔티티 태그들이 일치함을 또는 객체가 수정되었음을 나타내게 된다.

본 발명의 이태그 기술은 일반적으로 HTTP 프로토콜을 참조하여 설명되었지만, 당업자는 본 발명은 엔티티 태그 및 캐시 정보를 제공하기 위해 임의 타입 및/또는 형태의 프로토콜을 가지고 실시될 수도 있음을 인식 및 이해할 것이다. 일부 실시예들에서는, 프로토콜은 엔티티 태그 및 캐시 정보 필드를 지원할 수 없고, 다른 실시예들에서는, 프로토콜은 엔티티 태그 및 캐시 정보 필드를 지원할 수 있다. 이들 실시예들에서, 본 발명의 기술들은, 서버가 이 정보를 응답에서 제공하지 않을 때 또는 캐시가 어플라이언스(104)에 의해 제어되는 방식으로 또는 어플라이언 스(104)가 원하는 방식으로 서버에 의해 제공되는 엔티티 및 캐시 제어 정보를 변화 또는 제어하기로 판단할 때, 엔티티 태그 및 캐시 제어 정보를 제공한다.

시작 서버들 및 애플리케이션들에 의해 동적으로 발생된 콘텐트를 동적으로 캐싱하려는 도전을 처리하기 위해 본 발명의 캐시 어플라이언스는 흔히 사용되는 애플리케이션들, 예컨대 아웃룩 웹 액세스, 오라클 컨피규레이터(Configurator), 및 세라나 팀트랙(Serena TeamTrack)에 대한 사전 패키징된 정책들을 통합할 수 있다. 이들 패키지는 이러한 애플리케이션이 데이터를 처리하는 방식을 이해하고 설계되며, 이에 따라 캐시가 캐시 메모리에 저장된 이러한 애플리케이션들에 의해 발생된 객체들 및 이 객체를 얼마나 오래 유지할 수 있는지에 관하여 보다 지능적으로 판단하는 것을 가능하게 한다.

D. 예시적인 컴퓨터 시스템-기반 구현

본 발명의 기능은 하드웨어, 소프트웨어, 또는 그 조합을 사용하여 구현될 수 있고, 하나 이상의 컴퓨팅 장치 또는 다른 처리 시스템으로 구현될 수 있다. 예컨대, 도 8A 및 도 8B는 본 발명의 기술들, 방법들 및 기능을 구현하는데 사용될 수 있는 예시적인 컴퓨팅 장치(800)를 나타낸다. 이와 같이, 본 발명의 어플라이언스(104)는 여기서 설명되는 본 발명의 기술들, 기능 및 동작을 제공하도록 설계 및 구성된 컴퓨팅 장치(800) 또는 특수 장치일 수 있다.

도 8A 및 도 8B는 본 발명의 실시예를 실시하는데 유용한, 일부 실시예들에서는 네트워크 장치(800)라고도 하는 컴퓨팅 장치(800)의 블록도를 나타낸다. 도 8A 및 도 8B에 도시된 바와 같이, 각 컴퓨팅 장치(800)는 중앙 처리 장치(802) 및 메인 메모리 유닛(822)을 포함한다. 도 8A에 도시된 바와 같이, 일반적인 컴퓨팅 장치(800)는 비쥬얼 디스플레이 장치(824), 키보드(826) 및/또는 포인팅 장치(827), 예컨대 마우스를 포함할 수 있다. 각 컴퓨팅 장치(800)는 추가적인 선택적 소자들, 예컨대 하나 이상의 입력/출력 장치(830a-830b)(전반적으로 참조 번호 830으로 나타냄), 및 중앙 처리 장치(802)와 통신하는 캐시 메모리(840)를 더 포함할 수 있다.

중앙 처리 장치(802)는 메인 메모리 유닛(822)으로부터 페치된 명령들에 응답하고 그 명령들을 처리하는 로직 회로이다. 많은 실시예들에서, 중앙 처리 장치는 마이크로프로세서 유닛, 예컨대, 캘리포니아 마운틴 뷰 소재의 인텔 코포레이션에 의해 제조된 것; 일리노이즈 샤움버그 소재의 모토롤라 코포레이션에 의해 제조된 것; 캘리포니아 산타클라라 소재의 트랜스메타(Transmeta) 코포레이션에 의해 제조된 것, 뉴욕 화이트 플레인즈 소재의 인터내셔널 비즈니스 머신즈(International Business Machines) 에 의해 제조된 것; 또는 캘리포니아 서니베일 소재의 어드밴스드 마이크로 디바이시즈(Advanced Micro Devices)에 의해 제조된 것에 의해 제공된다. 컴퓨팅 장치(800)는 이들 프로세서 또는 여기서 설명되는 바와 같이 동작할 수 있는 다른 프로세서에 기초할 수 있다.

메인 메모리 유닛(822)은 데이터를 저장할 수 있고 기억 위치가 마이크로프로세서(802)에 의해 직접 액세스되는 것을 가능하게 하는 하나 이상의 메모리 칩, 예컨대 SRAM(static random access memory), 버스트(Burst) SRAM 또는 BSRAM(SynchBurst SRAM), DRAM(dynamic random access memory), FPM DRAM(Fast Page Mode DRAM), EDRAM(Enhanced DRAM), EDO RAM(Extended Data Output RAM), EDO DRAM(Extended Data Output DRAM), BEDO DRAM(Burst Extended Data Output DRAM), EDRAM(Enhanced DRAM), SDRAM(synchronous DRAM), JEDEC SRAM, PClOO SDRAM, DDR SDRAM(Double Data Rate SDRAM), ESDRAM(Enhanced SDRAM), SLDRAM(SyncLink DRAM), DRDRAM(Direct Rambus DRAM), 또는 FRAM(Ferroelectric RAM)일 수 있다. 메인 메모리(822)는 위에서 설명된 메모리 칩, 또는 여기서 설명되는 바와 같이 동작할 수 있는 어떤 다른 이용 가능 메모리 칩에 기초할 수 있다. 도 8A에 도시된 실시예에서, 프로세서(802)는 시스템 버스(850)(보다 상세히 후술됨)를 통해 메인 메모리(822)와 통신한다. 도 8A는 프로세서가 메모리 포트(803)를 통해 메인 메모리(822)와 직접 통신하는 컴퓨팅 장치(800)의 실시예를 나타낸다. 예컨대, 도 8B에서, 메인 메모리(822)는 DRDRAM일 수 있다.

도 8B는 메인 프로세서(802)가 종종 백사이드 버스라고도 하는 보조 버스를 통해 캐시 메모리(840)와 직접 통신하는 실시예를 나타낸다. 다른 실시예들에서, 메인 프로세서(802)는 시스템 버스(850)를 사용하여 캐시 메모리(840)와 통신한다. 캐시 메모리(840)는 일반적으로 메인 메모리(822)보다 빠른 응답 시간을 가지며, 일반적으로 SRAM, BSRAM, 또는 EDRAM에 의해 제공된다.

도 8A에 도시된 실시예에서, 프로세서(802)는 로컬 시스템 버스(850)를 통해 각종 I/O 장치(830)와 통신한다. 각종 버스들은 중앙 처리 장치(802)를 VESA VL 버스, ISA 버스, EISA 버스, MCA(McroChannel Architecture) 버스, PCI 버스, PCI-X 버스, PCI 익스프레스(PCI-Express) 버스, 또는 NuBus를 포함한 I/O 장치(830)에 연결하는데 사용될 수도 있다. I/O 장치가 비디오 디스플레이(824)인 실시예들의 경우, 프로세서(802)는 디스플레이(824)와 통신하기 위해 AGP(Advanced Graphics Port)를 사용할 수 있다. 도 8B는 메인 프로세서(802)가 하이퍼전송(HyperTransport), 고속 I/O, 또는 인피니밴드(InfiniBand)를 통해 I/O 장치(830b)와 직접 통신하는 컴퓨터(800)의 실시예를 나타낸다. 도 8B는 또한 로컬 버스들과 직접 통신이 혼합된 실시예를 나타낸다. 즉, 프로세서(802)는 로컬 상호 접속 버스를 사용하여 I/O 장치(830a)와 통신하고 I/O 장치(830b)와 직접 통신한다.

컴퓨팅 장치(800)는 어떤 적합한 설치 장치(816), 예컨대 플로피 디스크들, 예컨대 3.5-인치, 5.25-인치 디스크들 또는 ZIP 디스크들을 수납하기 위한 플로피 디스크 드라이브, CD-ROM 드라이브, CD-R/RW 드라이브, DVD-ROM 드라이브, 각종 포맷의 테이프 드라이브, USB 장치, 하드 드라이브, 또는 소프트웨어 및 프로그램들, 예컨대 소프트웨어(820) 또는 발명에 관련된 그 부분을 설치하거나 본 발명의 기술들을 제공하는데 적합한 어떤 다른 장치를 지원할 수 있다. 컴퓨팅 장치(800)는 운영체제 및 다른 관련 소프트웨어를 저장하고 애플리케이션 소프트웨어 프로그램들, 예컨대 본 발명의 소프트웨어 820에 관련된 프로그램을 저장하기 위한 기억 장치(828), 예컨대 하나 이상의 하드 디스크 드라이브 또는 독립된 디스크들의 리던던트 어레이를 더 포함할 수 있다. 선택적으로, 설치 장치들(816)은 기억 장치(828)로 사용될 수도 있다.

또한, 컴퓨팅 장치(800)는 표준 전화기 라인, LAN 또는 WAN 링크(예컨대, 802.11, Tl, T3, 56kb, X.25), 브로드밴드 접속(예컨대, ISDN, 프레임 릴레이(Frame Relay), ATM), 무선접속, 또는 상기 장치들의 일부 또는 모두의 조합(이에 한정되지 않음)을 포함한 다양한 접속을 통해 LAN(Local Area Network), WAN(Wide Area Network) 또는 인터넷에 인터페이싱하는 네트워크 인터페이스(818)를 포함할 수 있다. 네트워크 인터페이스(818)는 내장 네트워크 어댑터, 네트워크 인터페이스 카드, PCMCIA 네트워크 카드, 카드 버스 네트워크 어댑터, 무선 네트워크 어댑터, USB 네트워크 어댑터, 모뎀, 또는 컴퓨팅 장치(800)를 통신할 수 있고 여기서 설명되는 동작들을 수행할 수 있는 임의 타입의 네트워크에 인터페이싱하는데 적합한 어떤 다른 장치를 포함할 수 있다.

다양한 I/O 장치(830a-830n)는 컴퓨팅 장치(800)에 존재할 수 있다. 입력 장치들은 키보드, 마우스, 트랙 패드, 트랙볼, 마이크로폰, 및 드로잉 태블릿을 포함한다. 출력 장치는 비디오 디스플레이, 스피커, 잉크젯 프린터, 레이저 프린터, 및 염료 승화 방식 프린터를 포함한다. I/O 장치는 도 8A에 도시된 바와 같이 I/O 제어기(823)에 의해 제어될 수 있다. I/O 제어기는 하나 이상의 I/O 장치, 예컨대 키보드(826) 및 포인팅 장치(827), 예컨대, 마우스 또는 광학 펜을 제어할 수 있다. 또한, I/O 장치는 또한 컴퓨팅 장치(800)용 기억 장치(828) 및/또는 설치 매체(816)를 제공할 수 있다. 또 다른 실시예들에서, 컴퓨팅 장치(800)는 핸드헬드 USB 기억 장치, 예컨대 캘리포니아 로스 알라미토스 소재의 트윈테크 인더스트리 인코포레이티드에 의해 제조된 장치의 USB 플래시 드라이브 라인을 수납하기 위해 USB 접속을 제공할 수 있다.

다른 실시예들에서, I/O 장치(830)는 시스템 버스(850)와 외부 통신 버스 사이의 브리지(870)일 수 있고, 외부 통신 버스는 예컨대 USB 버스, 애플 데스크톱 버스, RS-232 시리얼 접속, SCSI 버스, 파이어 와이어(Fire Wire) 버스, 파이어 와이어 800 버스, 이더넷 버스, 애플 토크 버스, 기가비트 이더넷 버스, 비동기 전송 모드 버스, HIPPI 버스, 수퍼 HIPPI 버스, 시리얼 플러스 버스, SCI/LAMP 버스, 파이버 채널(FibreChannel) 버스, 또는 시리얼 부착형의 소형 컴퓨터 시스템 인터페이스 버스를 포함한다.

도 8 및 도 8B에 도시된 종류의 컴퓨팅 장치(800)는 일반적으로 작업 스케줄링 및 시스템 자원 액세스를 제어하는 운영체제의 제어 하에서 동작한다. 컴퓨팅 장치(800)는 임의 운영체제, 예컨대 마이크로소프트 윈도우즈 운영체제, 유닉스 및 리눅스 운영체제, 매킨토시 컴퓨터용 Mac OS, 임베디드 운영체제,y 네트워크 운영체제, 실시간 운영체제, 오픈 소스운영체제, 독점 운영체제, 모바일 컴퓨팅 장치 또는 네트워크 장치용 운영체제, 또는 컴퓨팅 장치상에서 구동될 수 있고 여기서 설명되는 동작들을 수행할 수 있는 어떤 다른 운영체제를 구동할 수 있다. 일반적인 운영체제는, 특히, 미국 워싱턴 레드몬드 소재의 마이크로소프트 코포레이션에 의해 제조된 윈도우즈 3.x, 윈도우즈 95, 윈도우즈 98, 윈도우즈 2000, 윈도우즈 NT 3.51, 윈도우즈 NT 4.0, 윈도우즈 CE, 및 윈도우즈 XP; 미국 캘리포니아 쿠퍼티노 소재의 애플 컴퓨터에 의해 제조된 MacOS; 미국 뉴욕 마몽크 소재의 인터내셔널 비즈니스 머신지에 의해 제조된 OS/2; 및 미국 유타 솔트 레이크 시티 소재의 칼 레라 코포레이션(Caldera Corp.)에 의해 제공된 무료 이용가능 운영체제인 리눅스, 또는 임의 타입 및/또는 형태의 유닉스 운영체제를 포함한다.

다른 실시예들에서, 컴퓨팅 장치(800)는 상기 장치와 호환되는 상이한 프로세서, 운영체제, 및 입력 장치를 가질 수 있다. 컴퓨팅 장치(800)는 워크스테이션, 데스크톱 컴퓨터, 랩톱 또는 노트북 컴퓨터, 서버, 핸드헬드 컴퓨터, 모바일 전화기, 다른 컴퓨터, 또는 통신을 할 수 있고 여기서 설명되는 본 발명의 동작을 수행하기에 충분한 프로세서 능력 및 메모리 용량을 가진 다른 형태의 컴퓨팅 또는 통신 장치일 수 있다. 또한, 컴퓨팅 장치(800)는 임의 타입 및/형태의 네트워크 장치, 예컨대 원격 액세스 장치, VPN(Virtual Private Network) 장치, SSL(Secure Socket Layer) VPN 장치, 라우터, 스위치, 브리지, 또는 여기서 설명되는 본 발명의 동작을 수행할 수 있는 임의 형태의 다른 네트워크 장치일 수 있다.

본 발명의 어플라이언스는 일반적으로 TCP/IP를 사용하여 설명하고 있거나 TCP/IP를 통해 통신하고 있지만, 어플라이언스는 수정된 전송 제어 프로토콜, 예컨대 T/TCP(Transaction TCP), TCP-SACK(TCP with selection acknowledgements), TCP-LW(TCP with large windows), TCP-Vegas 프로토콜에서와 같은 폭주 예측, 및 TCP 스푸핑(spoofing)을 이용하거나 그와 통신할 수 있다. 또한, 본 발명의 어플라이언스는 인터노드(internode) 또는 고성능 프로토콜을 이용할 수도 있다. 또한, 본 발명의 어플라이언스는 다른 전송 및 네트워크 프로토콜, 예컨대 IPX(Internetwork Packet Exchange) 프로토콜 상의 SPX(Sequenced packet exchange) 프로토콜을 사용하거나 그 프로토콜로 동작할 수 있다.

본 발명의 각종 실시예들에 대해 위에서 설명하였지만, 실시예들은 단지 예로서 제시된 것이며 한정하는 것이 아님을 이해해야 한다. 따라서, 청구 범위에 정의된 본 발명의 취지 및 범위로부터 벗어나지 않고 형태 및 세부 내용이 여러 가지로 변경될 수 있음을 이해할 것이다. 따라서, 본 발명의 범위는 상기한 실시예들에 의해 한정되어서는 안 되고 다음의 청구 범위 및 그 등가물에 따라서만 정의되어야 한다.

본 발명은 동적으로 발생된 데이터를 저장 및 서빙하는 캐시 메모리들의 능력을 증가시킨다. 본 발명은 또한 캐시가 다양하고 상이한 애플리케이션 요청 타입을 효과적으로 처리하는 것을 가능하게 함으로써, 애플리케이션 성능이 향상되고 캐시로부터 서빙되는 데이터의 새로움을 보존하기 위한 관리가 수월해진다.

Claims (167)

1. 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐싱하는 방법에 있어서,

   (a) 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐시에 저장하되, 상기 동적으로 발생된 객체는 시작 서버로부터 서빙되는 단계;

   (b) 상기 캐시가 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 요청을 수신하는 단계; 및

   (c) 상기 캐시가 상기 요청에 응답하여 상기 캐싱된 동적으로 발생된 객체를 무효로서 마킹하는 단계를 포함하는 객체 캐싱 방법.
2. 제1 항에 있어서,

   상기 시작 서버가 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 단계를 포함하는 객체 캐싱 방법.
3. 제2 항에 있어서,

   상기 시작 서버에서의 상기 동적으로 발생된 객체에 대한 변화에 응답하여 상기 시작 서버가 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 자동으로 요청하는 단계를 포함하는 객체 캐싱 방법.
4. 제1 항에 있어서,

   클라이언트가 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 단계를 포함하고, 상기 클라이언트는 상기 동적으로 발생된 객체를 수신하기 위해 상기 시작 서버와 통신하는 객체 캐싱 방법.
5. 제1 항에 있어서,

   외부 관리 제어기가 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 단계를 포함하는 객체 캐싱 방법.
6. 제1 항에 있어서,

   무효로 마킹된 상기 캐싱된 동적으로 발생된 객체를 상기 캐시로부터 플러싱(flushing)하는 단계를 포함하는 객체 캐싱 방법.
7. 제1 항에 있어서,

   상기 캐시가 상기 동적으로 발생된 객체를 캐싱하는 10 밀리초 또는 10 밀리초보다 짧은 시간 내에서 무효화하라는 요청을 수신하는 단계를 포함하는 객체 캐싱 방법.
8. 제1 항에 있어서,

   상기 캐시가 10 밀리초 또는 10 밀리초보다 짧은 시간의 상기 캐싱된 동적으 로 발생된 객체의 만기의 만료에 응답하여 무효화하라는 요청을 수신하는 단계를 포함하는 객체 캐싱 방법.
9. 제1 항에 있어서,

   상기 시작 서버와 클라이언트 간의 통신시 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 중 하나 상에서 상기 캐시를 동작시키는 단계를 포함하는 객체 캐싱 방법.
10. 캐싱 가능으로 식별되지 않은 적어도 하나의 객체를 가진 동적으로 발생된 객체들의 그룹을 캐싱하는 방법에 있어서,

    (a) 시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹을 캐시에서 식별하되, 상기 동적으로 발생된 객체들 중 적어도 하나는 캐싱 가능으로 식별되지 않은 단계;

    (b) 상기 캐시가 상기 그룹을 객체 결정인자와 연관시키는 단계; 및

    (c) 상기 캐시가 상기 그룹의 객체 결정인자를 식별하는 통신을 인터셉트하고, 상기 그룹의 객체들 중 하나의 객체에 대한 변화가 상기 시작 서버상에서 막 일어나려하는지 아니면 일어났는지를 나타내는 단계를 포함하는 객체 그룹 캐싱 방법.
11. 제9 항에 있어서,

    상기 캐시가 상기 통신의 수신에 응답하여 상기 동적으로 발생된 객체들의 그룹을 무효로 마킹하는 단계를 포함하는 객체 그룹 캐싱 방법.
12. 제10 항에 있어서,

    무효로 마킹된 객체 그룹을 상기 캐시로부터 플러싱하는 단계를 포함하는 객체 그룹 캐싱 방법.
13. 제9 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹은 미리 지정된 객체 그룹 캐싱 방법.
14. 제9 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹을 자동으로 식별하고, 상기 객체 결정인자를 규칙에 따라 상기 그룹과 연관시키는 단계를 더 포함하는 객체 그룹 캐싱 방법.
15. 동적으로 발생된 객체들의 캐시를 유지하는 방법에 있어서,

    (a) 캐시가 클라이언트와 시작 서버 간의 통신을 인터셉트하는 단계;

    (b) 상기 캐시가 상기 시작 서버에서 동적으로 발생된 객체에 대한 변화가 일어났는지 아니면 일어날 것인지를 나타내는 객체 결정인자를 상기 통신에서 식별하는 단계; 및

    (c) 상기 캐시가 상기 캐시에 저장된 상기 동적으로 발생된 객체를 무효로 마킹하는 단계를 포함하는 캐시 유지 방법.
16. 제15 항에 있어서,

    상기 시작 서버로부터 상기 동적으로 발생된 객체를 얻는 단계를 포함하는 캐시 유지 방법.
17. 제15 항에 있어서,

    상기 무효인, 동적으로 발생된 객체를 상기 캐시로부터 플러싱하는 단계를 포함하는 캐시 유지 방법.
18. 제15 항에 있어서,

    상기 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않은 캐시 유지 방법.
19. 제15 항에 있어서,

    (e) 상기 캐시에서, 상기 동적으로 발생된 객체를 상기 시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹과 연관시키는 단계;

    (f) 상기 캐시가 상기 그룹을 상기 객체 결정인자와 연관시키는 단계; 및

    (g) 상기 캐시가 상기 통신에 응답하여 상기 동적으로 발생된 객체들의 그룹을 무효로 마킹하는 단계를 포함하는 캐시 유지 방법.
20. 제19 항에 있어서,

    무효로 마킹된 상기 동적으로 발생된 객체들의 그룹을 상기 캐시로부터 플러싱하는 단계를 포함하는 캐시 유지 방법.
21. 제19 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹은 미리 지정된 캐시 유지 방법.
22. 제19 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹을 자동으로 식별하고, 상기 객체 결정인자를 규칙에 따라 상기 그룹과 연관시키는 단계를 더 포함하는 캐시 유지 방법.
23. 제15 항에 있어서,

    상기 클라이언트가 상기 객체 결정인자를 미리 정의된 스트링으로서 상기 통신에 삽입하는 단계를 포함하는 캐시 유지 방법.
24. 제15 항에 있어서,

    상기 동적으로 발생된 객체와 연관된 미리 정의된 발견적인(heuristic) 규칙에 기초하여 상기 객체 결정인자를 식별하는 단계를 포함하는 캐시 유지 방법.
25. 제15 항에 있어서,

    상기 캐시가 다음의 통신 요소들, 즉 USERID, IP 주소, TCP 포트, HTTP 헤더, 커스텀 HTTP 헤더, 클라이언트 URL, 쿠키 헤더, URL 질의 스트링 및 POST 바디 중 하나로부터 상기 객체 결정인자를 선택하는 단계를 포함하는 캐시 유지 방법.
26. 제15 항에 있어서,

    상기 캐시가 사용자-구성된 무효화 정책에 기초하여 상기 객체 결정인자를 상기 통신으로부터 추출하는 단계를 포함하는 캐시 유지 방법.
27. 제15 항에 있어서,

    상기 객체 결정인자를 상기 캐시에 저장된 하나 이상의 객체들 또는 객체 그룹들과 연관시키기 위해 상기 캐시 내에 테이블을 유지하는 단계를 포함하는 캐시 유지 방법.
28. 제15 항에 있어서,

    지능형 통계 엔진이 상기 캐시에 저장할 한 세트의 동적으로 발생된 객체들을 식별하기 위해 상기 클라이언트로부터의 통신을 검사하는 단계를 포함하는 캐시 유지 방법.
29. 제15 항에 있어서,

    상기 캐시가 상기 캐시에 저장된 객체들을 콘텐트 그룹에 연관시키는 단계를 포함하고, 상기 콘텐트 그룹은 구체화 번호(incarnation number)를 인덱스로서 가진 해쉬 테이블에 의해 표현되는 캐시 유지 방법.
30. 제15 항에 있어서,

    상기 동적으로 발생된 객체에 대한 변화를 결정하기 위해 상기 통신을 통해 식별된 상기 동적으로 발생된 객체에 대해 상기 캐시가 해쉬 알고리즘을 수행하는 단계를 포함하는 캐시 유지 방법.
31. 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐싱하는 시스템에 있어서,

    캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐시에 저장하되, 상기 동적으로 발생된 객체는 시작 서버로부터 서빙되는 수단;

    상기 캐싱된 동적으로 발생된 객체를 무효화하라는 요청을 상기 캐시에 의해 수신하는 수단; 및

    상기 요청에 응답하여 상기 캐싱된 동적으로 발생된 객체를 무효로서 상기 캐시에 의해 마킹하는 수단을 포함하는 객체 캐싱 시스템.
32. 제31 항에 있어서 ,

    상기 시작 서버에 의해, 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 수단을 포함하는 객체 캐싱 시스템.
33. 제31 항에 있어서,

    상기 시작 서버에서의 상기 동적으로 발생된 객체에 대한 변화에 응답하여 상기 시작 서버에 의해 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 자동으로 요청하는 수단을 포함하는 객체 캐싱 시스템.
34. 제31 항에 있어서,

    클라이언트에 의해, 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 수단을 포함하고, 상기 클라이언트는 상기 동적으로 발생된 객체를 수신하기 위해 상기 시작 서버와 통신하는 객체 캐싱 시스템.
35. 제31 항에 있어서,

    외부 관리 제어기에 의해, 상기 캐싱된 동적으로 발생된 객체를 무효화할 것을 요청하는 수단을 포함하는 객체 캐싱 시스템.
36. 제31 항에 있어서,

    무효로 마킹된 상기 캐싱된 동적으로 발생된 객체를 상기 캐시로부터 플러싱하는 수단을 포함하는 객체 캐싱 시스템.
37. 제30 항에 있어서,

    상기 동적으로 발생된 객체를 캐싱하는 10 밀리초 또는 10 밀리초보다 짧은 시간 내에 무효화 요청을 수신하는 수단을 포함하는 객체 캐싱 시스템.
38. 제31 항에 있어서,

    상기 동적으로 발생된 객체를 캐싱하는 10 밀리초 또는 10 밀리초보다 짧은 시간 내에 무효화 요청을 수신하는 수단을 포함하는 객체 캐싱 시스템.
39. 제31 항에 있어서,

    상기 캐시에 의해, 10 밀리초 또는 10 밀리초보다 짧은 시간의 상기 캐싱된 동적으로 발생된 객체의 만기의 만료에 응답하여 무효화하라는 요청을 수신하는 수단을 포함하는 객체 캐싱 시스템.
40. 제31 항에 있어서,

    상기 캐시는 상기 시작 서버와 클라이언트 간의 통신시 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 중 하나 상에서 동작하는 단계를 포함하는 객체 캐싱 시스템.
41. 캐싱 가능으로 식별되지 않은 적어도 하나의 객체를 가진 동적으로 발생된 객체들의 그룹을 캐싱하는 시스템에 있어서,

    시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹을 캐시에서 식별하되, 상기 동적으로 발생된 객체들 중 적어도 하나는 캐싱 가능으로 식별되지 않은 수단;

    상기 캐시에 의해, 상기 그룹을 객체 결정인자와 연관시키는 수단; 및

    상기 캐시에 의해, 상기 그룹의 객체 결정인자를 식별하는 통신을 인터셉트하고, 상기 그룹의 객체들 중 하나의 객체에 대한 변화가 상기 시작 서버상에서 막 일어나려하는지 아니면 일어났는지를 나타내는 수단을 포함하는 객체 그룹 캐싱 시스템.
42. 제41 항에 있어서,

    상기 캐시에 의해, 상기 통신의 수신에 응답하여 상기 동적으로 발생된 객체들의 그룹을 무효로 마킹하는 수단을 포함하는 객체 그룹 캐싱 시스템.
43. 제41 항에 있어서,

    무효로 마킹된 객체 그룹을 상기 캐시로부터 플러싱하는 수단을 포함하는 객체 그룹 캐싱 시스템.
44. 제41 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹은 미리 지정된 객체 그룹 캐싱 시스템.
45. 제41항에 있어서,

    상기 동적으로 발생된 객체들의 그룹을 자동으로 식별하고, 상기 객체 결정인자를 규칙에 따라 상기 그룹과 연관시키는 수단을 포함하는 객체 그룹 캐싱 시스템.
46. 동적으로 발생된 객체들의 캐시를 유지하는 시스템에 있어서,

    (a) 캐시가 클라이언트와 시작 서버 간의 통신을 인터셉트하는 수단;

    (b) 상기 캐시가 상기 시작 서버에서 동적으로 발생된 객체에 대한 변화가 일어났는지 아니면 일어날 것인지를 나타내는 객체 결정인자를 상기 통신에서 식별하는 수단; 및

    (c) 상기 캐시가 상기 캐시에 저장된 상기 동적으로 발생된 객체를 무효로 마킹하는 수단을 포함하는 캐시 유지 시스템.
47. 제46 항에 있어서,

    상기 시작 서버로부터 상기 동적으로 발생된 객체를 얻는 수단을 포함하는 캐시 유지 시스템.
48. 제46 항에 있어서,

    상기 무효인, 동적으로 발생된 객체를 상기 캐시로부터 플러싱하는 수단을 포함하는 캐시 유지 시스템.
49. 제46 항에 있어서,

    상기 캐시에서, 상기 동적으로 발생된 객체를 상기 시작 서버로부터 이전에 서빙된 동적으로 발생된 객체들의 그룹과 연관시키는 수단;

    상기 캐시에 의해, 상기 그룹을 상기 객체 결정인자와 연관시키는 수단; 및

    상기 캐시에 의해, 상기 통신에 응답하여 상기 동적으로 발생된 객체들의 그룹을 무효로 마킹하는 수단을 포함하는 캐시 유지 시스템.
50. 제46 항에 있어서,

    상기 동적으로 발생된 객체는 캐싱 불가능한 것으로 식별되는 캐시 유지 시스템.
51. 제46 항에 있어서,

    무효로 마킹된 상기 동적으로 발생된 객체들의 그룹을 상기 캐시로부터 플러싱하는 수단을 포함하는 캐시 유지 시스템.
52. 제46 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹은 미리 지정된 캐시 유지 시스템.
53. 제46 항에 있어서,

    상기 동적으로 발생된 객체들의 그룹을 자동으로 식별하고, 상기 객체 결정인자를 규칙에 따라 상기 그룹과 연관시키는 수단을 더 포함하는 캐시 유지 시스템.
54. 제46 항에 있어서,

    상기 클라이언트에 의해, 상기 객체 결정인자를 미리 정의된 스트링으로서 상기 통신에 삽입하는 수단을 포함하는 캐시 유지 시스템.
55. 제46 항에 있어서,

    상기 동적으로 발생된 객체와 연관된 미리 정의된 발견적인(heuristic) 규칙에 기초하여 상기 객체 결정인자를 식별하는 수단을 포함하는 캐시 유지 시스템.
56. 제46 항에 있어서,

    상기 캐시에 의해, 다음의 통신 요소들, 즉 USERID, IP 주소, TCP 포트, HTTP 헤더, 커스텀 HTTP 헤더, 클라이언트 URL, 쿠키 헤더, URL 질의 스트링 및 POST 바디 중 하나로부터 상기 객체 결정인자를 선택하는 수단을 포함하는 캐시 유지 시스템.
57. 제46 항에 있어서,

    상기 캐시에 의해, 사용자-구성된 무효화 정책에 기초하여 상기 객체 결정인 자를 상기 통신으로부터 추출하는 수단을 포함하는 캐시 유지 시스템.
58. 제46 항에 있어서,

    상기 객체 결정인자를 상기 캐시에 저장된 하나 이상의 객체들 또는 객체 그룹들과 연관시키기 위해 상기 캐시 내에 테이블을 유지하는 수단을 포함하는 캐시 유지 시스템.
59. 제46 항에 있어서,

    지능형 통계 엔진에 의해, 상기 캐시에 저장할 한 세트의 동적으로 발생된 객체들을 식별하기 위해 상기 클라이언트로부터의 통신을 검사하는 수단을 포함하는 캐시 유지 시스템.
60. 제46 항에 있어서,

    상기 캐시에 의해, 상기 캐시에 저장된 객체들을 콘텐트 그룹에 연관시키는 수단을 포함하고, 상기 콘텐트 그룹은 구체화 번호를 인덱스로서 가진 해쉬 테이블에 의해 표현되는 캐시 유지 시스템.
61. 제46 항에 있어서,

    상기 동적으로 발생된 객체에 대한 변화를 결정하기 위해 상기 통신을 통해 식별된 상기 동적으로 발생된 객체에 대해 상기 캐시가 해쉬 알고리즘을 수행하는 수단을 포함하는 캐시 유지 시스템.
62. 적어도 하나의 동적으로 발생된 객체를 구비하는 네트워크 패킷들을 처리하고, 상기 적어도 하나의 동적으로 발생된 객체를 캐시에 저장하는 장치의 패킷 처리 엔진에서, 패킷 처리 타이머의 신호에 응답하여 상기 캐시에 캐싱된 동적으로 발생된 객체를 무효화하는 방법에 있어서,

    (a) 네트워크 패킷을 처리하기 위해 패킷 처리 타이머로부터 제1 신호를 수신하는 단계;

    (b) 상기 신호에 응답하여 상기 네트워크 패킷을 처리하는 단계; 및

    (c) 캐싱된 동적으로 발생된 객체가 무효임을 나타내는 제2 신호를 캐시에 전송하는 단계를 포함하는 객체 무효화 방법.
63. 제62 항에 있어서,

    상기 제2 신호에 의해, 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 무효화 명령을 제공하는 단계를 포함하는 객체 무효화 방법.
64. 제62 항에 있어서,

    상기 제2 신호에 의해, 상기 캐싱된 동적으로 발생된 객체의 만기의 만료를 제공하는 단계를 포함하는 객체 무효화 방법.
65. 제62 항에 있어서,

    상기 단계 (c)는 상기 네트워크 패킷의 처리 동안에 수행되는 객체 무효화 방법.
66. 제62 항에 있어서,

    상기 단계 (c)는 상기 네트워크 패킷의 처리 완료시 수행되는 객체 무효화 방법.
67. 제62 항에 있어서,

    1 밀리초 이상의 시간 증분에 상기 패킷 처리 타이머를 동작시키는 단계를 포함하는 객체 무효화 방법.
68. 제62 항에 있어서,

    10 밀리초와 동일하거나 짧은 만기 시간에 캐시에 저장된 객체를 무효화하기 위한 시간 증분에서 상기 패킷 처리 타이머를 동작시키는 단계를 포함하는 객체 무효화 방법.
69. 제62 항에 있어서,

    상기 캐시가 상기 캐싱된 동적으로 발생된 객체를 무효로 마킹하는 단계를 포함하는 객체 무효화 방법.
70. 제62 항에 있어서,

    상기 장치는 브리지, 라우터, 스위치, 및 SSL VPN 장치 중 하나를 구비하는 객체 무효화 방법.
71. 제62 항에 있어서,

    상기 장치의 커널 공간에서 상기 캐시, 상기 패킷 처리 엔진, 또는 상기 패킷 처리 타이머 중 하나를 동작시키는 단계를 포함하는 객체 무효화 방법.
72. 제62 항에 있어서,

    시작 서버로부터의 상기 동적으로 발생된 객체를 동적으로 발생하고 서빙하는 시간 기간보다 짧거나 같은 상기 캐싱된 동적으로 발생된 객체의 만기 시간 간격을 상기 패킷 처리 타이머를 통해 제공하는 단계를 포함하는 객체 무효화 방법.
73. 제62 항에 있어서,

    동적으로 발생된 객체를 포함하는 상기 네트워크 패킷을 시작 서버로부터 송신하는 단계를 포함하는 객체 무효화 방법.
74. 제62 항에 있어서,

    상기 동적으로 발생된 객체는 캐싱 불가능한 것으로 식별된 객체 무효화 방 법.
75. 패킷 처리 타이머의 신호에 응답하여 캐싱된 동적으로 발생된 객체를 무효화하기 위한 장치에 있어서, 상기 객체 무효화 장치는 적어도 하나의 동적으로 발생된 객체를 포함하는 네트워크 패킷들을 처리하고 상기 적어도 하나의 동적으로 발생된 객체를 캐시에 저장하며, 상기 객체 무효화 장치는,

    제1 신호를 발생하는 패킷 처리 타이머;

    상기 패킷 처리 타이머와 통신하고, 상기 패킷 처리 타이머의 제1 신호의 수신에 응답하여 상기 네트워크 패킷을 처리하는 패킷 처리 엔진; 및

    상기 패킷 처리 엔진과 통신하고, 기억 소자에 캐싱된 동적으로 발생된 객체를 가진 캐시를 포함하고,

    상기 캐시는 상기 캐싱된 동적으로 발생된 객체가 무효임을 나타내는 제2 신호를 상기 패킷 처리 엔진으로부터 수신하는 객체 무효화 장치.
76. 제75 항에 있어서,

    상기 제2 신호는 상기 캐싱된 동적으로 발생된 객체를 무효화하라는 무효화 명령을 포함하는 객체 무효화 장치.
77. 제75 항에 있어서,

    상기 제2 신호는 상기 캐싱된 동적으로 발생된 객체의 만기의 만료를 포함하 는 객체 무효화 장치.
78. 제75 항에 있어서,

    상기 패킷 처리 엔진은 상기 패킷 처리 엔진에 의한 상기 네트워크 패킷의 처리 동안에 상기 제2 신호를 상기 캐시에 전송하는 객체 무효화 장치.
79. 제75 항에 있어서,

    상기 패킷 처리 엔진은 상기 네트워크 패킷의 처리 완료시 상기 제2 신호를 상기 캐시에 전송하는 객체 무효화 장치.
80. 제75 항에 있어서,

    상기 패킷 처리 타이머는 1 밀리초 이상의 시간 간격으로 동작하는 객체 무효화 장치.
81. 제75 항에 있어서,

    상기 패킷 처리 타이머는 10 밀리초와 동일하거나 짧은 제1 시간 간격으로 캐싱된 객체를 무효화하기 위해 상기 제2 신호를 상기 캐시에 대해 트리거하는 시간 간격으로 동작하는 객체 무효화 장치.
82. 제75 항에 있어서,

    상기 장치는 브리지, 라우터, 스위치, 및 SSL VPN 장치 중 하나를 포함하는 객체 무효화 장치.
83. 제75 항에 있어서,

    상기 캐시, 상기 패킷 처리 엔진, 또는 상기 패킷 처리 타이머 중 하나는 상기 장치의 커널 공간에서 동작하는 객체 무효화 장치.
84. 제75 항에 있어서,

    상기 패킷 처리 타이머는 시작 서버로부터의 상기 동적으로 발생된 객체를 동적으로 발생하고 서빙하는 시간 기간보다 짧거나 같은 상기 캐싱된 동적으로 발생된 객체의 만기 시간 간격을 제공하는 객체 무효화 장치.
85. 제75 항에 있어서,

    시작 서버가 동적으로 발생된 객체를 포함하는 상기 네트워크 패킷을 전송하는 객체 무효화 장치.
86. 제75 항에 있어서,

    상기 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않는 객체 무효화 장치.
87. 복수의 클라이언트로부터 동적으로 발생된 객체에 대한 요청에 응답하는 방법에 있어서,

    (d) 장치가 동적으로 발생된 객체에 대한 제1 클라이언트의 제1 요청에 대한 응답을 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 단계;

    (e) 상기 장치가 패킷 처리 엔진에 상기 응답을 제1 클라이언트에 전송할 것을 요청하되, 상기 응답은 전송 대기하면서 버퍼에 홀딩되는 단계;

    (f) 상기 제1 클라이언트로의 상기 응답의 전송 완료 전에 상기 장치가 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하는 단계; 및

    (g) 상기 장치가 상기 버퍼에 홀딩된 상기 제1 클라이언트에 대한 응답의 동적으로 발생된 객체를 상기 제2 클라이언트에 전송할 것을 상기 패킷 처리 엔진에 요청하는 응답 방법.
88. 제87 항에 있어서,

    상기 패킷 처리 엔진이 상기 응답을 상기 제1 클라이언트에 전송하는 단계를 포함하는 응답 방법.
89. 제87 항에 있어서,

    상기 패킷 처리 엔진이 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제2 클라이언트에 전송하는 단계를 포함하는 응답 방법.
90. 제87 항에 있어서,

    상기 패킷 처리 엔진이 상기 제1 클라이언트 또는 제2 클라이언트 중 하나에 상기 응답을 전송한 후 상기 버퍼로부터 상기 응답을 제거하는 단계를 포함하는 응답 방법.
91. 제87 항에 있어서,

    상기 버퍼는 TCP/IP 버퍼 또는 상기 장치의 TCP/IP 스택의 일부 중 하나를 포함하는 응답 방법.
92. 제87 항에 있어서,

    상기 장치는 상기 제1 클라이언트 및 제2 클라이언트로 전송하기 위한 단일 TCP/IP 스택을 포함하고, 상기 버퍼는 상기 단일 TCP/IP 스택과 연관된 응답 방법.
93. 제87 항에 있어서,

    상기 단계 (c)는 상기 장치가 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하는 단계를 더 포함하고,

    상기 단계 (d)는 상기 장치가 상기 버퍼에 홀딩된 제1 클라이언트에 대한 응답의 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송할 것을 요청하는 단계를 더 포함하는 응답 방법.
94. 제87 항에 있어서,

    상기 패킷 처리 엔진이 상기 제1 클라이언트의 네트워크에의 접속에 관련된 하나 이상의 특징에 기초하여 상기 제1 클라이언트에 대한 응답을 홀딩하는 단계를 포함하는 응답 방법.
95. 제87 항에 있어서,

    상기 장치가 상기 제2 요청을 큐잉하는 단계를 포함하는 응답 방법.
96. 제87 항에 있어서,

    상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 제2 클라이언트에 전송한 후 상기 동적으로 발생된 객체를 상기 버퍼로부터 제거하는 단계를 포함하는 응답 방법.
97. 제87 항에 있어서,

    상기 동적으로 발생된 객체는 캐싱 불가능으로 식별되는 응답 방법.
98. 제87 항에 있어서,

    상기 장치는, 상기 제2 요청이 상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 단계를 포 함하는 응답 방법.
99. 제87 항에 있어서,

    상기 장치는 상기 제1 클라이언트와 상기 시작 서버 간의 통신시 어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 중 하나를 구비하는 응답 방법.
100. 제87 항에 있어서,

     상기 장치는 상기 패킷 처리 엔진과 통신하는 캐시를 포함하는 응답 방법.
101. 제100 항에 있어서,

     상기 캐시가 상기 제1 클라이언트에 대한 응답 또는 상기 제1 클라이언트의 동적으로 발생된 객체 중 하나를 상기 제2 클라이언트로 전송할 것을 상기 패킷 처리 엔진에 요청하는 단계를 포함하는 응답 방법.
102. 복수의 클라이언트로부터 동적으로 발생된 객체에 대한 요청에 응답하는 시스템에 있어서,

     장치가 동적으로 발생된 객체에 대한 제1 클라이언트의 제1 요청에 대한 응답을 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 장치;

     상기 장치로부터 전송 대기 중인 하나 이상의 네트워크 패킷을 홀딩하는 버 퍼;

     상기 응답을 제1 클라이언트에 전송하라는 요청을 상기 장치로부터 수신하는 패킷 처리 엔진을 포함하고,

     상기 버퍼는 상기 응답을 포함하는 하나 이상의 네트워크 패킷을 홀딩하며,

     상기 장치는 상기 제1 클라이언트로의 상기 응답의 전송 완료 전에 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하고, 상기 버퍼에 홀딩된 상기 제1 클라이언트에 대한 응답의 동적으로 발생된 객체를 상기 제2 클라이언트에 전송할 것을 상기 패킷 처리 엔진에 요청하는 응답 시스템.
103. 제102 항에 있어서,

     상기 패킷 처리 엔진은 상기 응답을 상기 제1 클라이언트에 전송하는 응답 시스템.
104. 제102 항에 있어서,

     상기 패킷 처리 엔진은 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 상기 버퍼로부터 상기 제2 클라이언트로 전송하는 응답 시스템.
105. 제102 항에 있어서,

     상기 패킷 처리 엔진은 상기 제1 클라이언트 또는 제2 클라이언트 중 하나에 상기 응답을 전송한 후 상기 버퍼로부터 상기 응답을 제거하는 응답 시스템.
106. 제102 항에 있어서,

     상기 버퍼는 TCP/IP 버퍼 또는 상기 장치의 TCP/IP 스택의 일부 중 하나를 포함하는 응답 시스템.
107. 제102 항에 있어서,

     상기 장치는 상기 제1 클라이언트 및 제2 클라이언트로 전송하기 위한 단일 TCP/IP 스택을 포함하고, 상기 버퍼는 상기 단일 TCP/IP 스택과 연관된 응답 시스템.
108. 제102 항에 있어서,

     상기 장치는 상기 장치가 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하고,

     상기 장치는 상기 버퍼에 홀딩된 제1 클라이언트에 대한 응답의 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송할 것을 상기 패킷 처리 엔진에 요청하는 응답 시스템.
109. 제102 항에 있어서,

     상기 패킷 처리 엔진은 상기 제1 클라이언트의 네트워크에의 접속에 관련된 하나 이상의 특징에 기초하여 상기 제1 클라이언트에 대한 응답을 홀딩하는 응답 시스템.
110. 제102 항에 있어서,

     상기 장치는 상기 제2 요청을 큐잉하는 응답 시스템.
111. 제102 항에 있어서,

     상기 패킷 처리 엔진은 상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 제2 클라이언트에 전송한 후 상기 동적으로 발생된 객체를 상기 버퍼로부터 제거하는 응답 시스템.
112. 제102 항에 있어서,

     상기 동적으로 발생된 객체는 캐싱 불가능으로 식별되는 응답 시스템.
113. 제102 항에 있어서,

     상기 장치는, 상기 제2 요청이 상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 응답 시스템.
114. 제102 항에 있어서,

     상기 장치는 상기 제1 클라이언트와 상기 시작 서버 간의 통신시 어플라이언 스, 네트워크 장치 또는 컴퓨팅 장치 중 하나를 구비하는 응답 시스템.
115. 제102 항에 있어서,

     상기 장치는 상기 패킷 처리 엔진과 통신하는 캐시를 포함하는 응답 시스템.
116. 제115 항에 있어서,

     상기 캐시는 상기 제1 클라이언트에 대한 응답 또는 상기 제1 클라이언트의 동적으로 발생된 객체 중 하나를 상기 제2 클라이언트로 전송할 것을 상기 패킷 처리 엔진에 요청하는 응답 시스템.
117. 네트워크 장치에서, 복수의 클라이언트로부터의 동적으로 발생된 객체에 대한 요청에 응답하는 방법에 있어서,

     (h) 시작 서버로부터의 제1 동적으로 발생된 객체에 대한 요청을 제1 클라이언트로부터 수신하는 단계;

     (i) 상기 제1 요청을 상기 시작 서버에 전송하는 단계;

     (j) 제1 클라이언트의 제1 요청에 응답하기 전에 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하는 단계;

     (k) 제1 요청에 대한 응답을 상기 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 단계; 및

     (1) 상기 제1 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제1 클라 이언트에 전송하고, 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 제2 클라이언트에 전송하는 단계를 포함하는 응답 방법.
118. 제117 항에 있어서,

     단계 (c)는 상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하는 단계를 더 포함하고,

     단계 (e)는 각 클라이언트의 요청에 응답하여 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송하는 단계를 더 포함하는 응답 방법.
119. 제117 항에 있어서,

     (f) 상기 동적으로 발생된 객체를 상기 제2 클라이언트에 전송 완료하기 전에 상기 동적으로 발생된 객체에 대한 제3 요청을 제3 클라이언트로부터 수신하는 단계; 및

     (g) 상기 제3 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제3 클라이언트에 전송하는 단계를 포함하는 응답 방법.
120. 제117 항에 있어서,

     상기 제1 요청 및 상기 제2 요청을 거의 동시에 수신하는 단계를 포함하는 응답 방법.
121. 제117 항에 있어서,

     상기 제2 요청을 큐잉하는 단계를 포함하는 응답 방법.
122. 제117 항에 있어서,

     상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 상기 제2 클라이언트에 전송한 후에 상기 동적으로 발생된 객체를 캐시로부터 플러싱하는 단계를 포함하는 응답 방법.
123. 제117 항에 있어서,

     상기 동적으로 발생된 객체는 캐싱 불가능으로 식별되는 응답 방법.
124. 제117 항에 있어서,

     상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제2 요청은 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 단계를 포함하는 응답 방법.
125. 제117 항에 있어서,

     엔티티 태그 헤더 또는 캐시-제어 헤더를 포함하도록 상기 응답을 수정하고, 상기 수정된 응답을 상기 제1 클라이언트 또는 상기 제2 클라이언트에 전송하는 단계를 포함하는 응답 방법.
126. 복수의 클라이언트로부터 동적으로 발생된 객체에 대한 요청에 응답하는 네트워크 장치에 있어서,

     시작 서버로부터의 제1 동적으로 발생된 객체에 대한 요청을 제1 클라이언트로부터 수신하는 수단;

     상기 제1 요청을 상기 시작 서버에 전송하는 수단;

     제1 클라이언트의 제1 요청에 응답하기 전에 상기 동적으로 발생된 객체에 대한 제2 요청을 제2 클라이언트로부터 수신하는 수단;

     제1 요청에 대한 응답을 상기 시작 서버로부터 수신하되, 상기 응답은 상기 동적으로 발생된 객체를 포함하는 수단; 및

     상기 제1 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제1 클라이언트에 전송하고, 상기 제2 요청에 응답하여 상기 동적으로 발생된 객체를 제2 클라이언트에 전송하는 수단을 포함하는 네트워크 장치.
127. 제126 항에 있어서,

     상기 동적으로 발생된 객체에 대한 복수의 요청을 복수의 클라이언트로부터 수신하고, 각 클라이언트의 요청에 응답하여 상기 동적으로 발생된 객체를 상기 복수의 클라이언트에 전송하는 수단을 더 포함하는 네트워크 장치.
128. 제126 항에 있어서,

     상기 동적으로 발생된 객체를 상기 제2 클라이언트에 전송 완료하기 전에 상기 동적으로 발생된 객체에 대한 제3 요청을 제3 클라이언트로부터 수신하는 수단; 및

     상기 제3 요청에 응답하여 상기 동적으로 발생된 객체를 상기 제3 클라이언트에 전송하는 수단을 포함하는 네트워크 장치.
129. 제126 항에 있어서,

     상기 제1 요청 및 상기 제2 요청을 거의 동시에 수신하는 수단을 포함하는 네트워크 장치.
130. 제126 항에 있어서,

     상기 네트워크 장치는 상기 제2 요청을 큐잉하는 네트워크 장치.
131. 제126 항에 있어서,

     상기 동적으로 발생된 객체를 상기 제1 클라이언트 및 상기 제2 클라이언트에 전송한 후에 상기 동적으로 발생된 객체를 캐시로부터 플러싱하는 수단을 포함하는 네트워크 장치.
132. 제126 항에 있어서,

     상기 동적으로 발생된 객체는 캐싱 가능으로 식별되지 않는 네트워크 장치.
133. 제126 항에 있어서,

     상기 제2 요청과 연관된 객체 결정인자를 통해 상기 제2 요청은 상기 제1 요청의 상기 동적으로 발생된 객체에 대한 것으로 판단하는 수단을 포함하는 네트워크 장치.
134. 제126 항에 있어서,

     상기 네트워크 장치는 상기 클라이언트와 상기 시작 서버 간의 통신시 어플라이언스 또는 컴퓨팅 장치 중 하나를 포함하는 네트워크 장치.
135. 제126 항에 있어서,

     엔티티 태그 헤더 또는 캐시-제어 헤더 중 하나를 포함하도록 상기 응답을 수정하고, 상기 수정된 응답을 상기 제1 클라이언트 또는 상기 제2 클라이언트 중 하나에 전송하는 수단을 포함하는 네트워크 장치.
136. 캐싱 가능으로 식별되지 않은 동적으로 발생된 객체를 캐싱하기 위한 엔티티 태그 이용 방법에 있어서,

     캐시가 동적으로 발생된 객체에 대한 클라이언트의 요청에 대한 응답을 시작 서버로부터 수신하되, 상기 동적으로 발생된 객체는 캐싱 불가능한 것으로 식별된 단계;

     (n) 상기 캐시가 상기 캐시에 저장된 상기 동적으로 발생된 객체에 대한 엔티티 태그를 발생하는 단계;

     (o) 상기 캐시가 상기 발생된 엔티티 태그를 포함하도록 상기 응답을 수정하는 단계; 및

     (p) 상기 캐시가 상기 동적으로 발생된 객체를 캐싱 가능으로 식별하는 상기 수정된 응답을 상기 클라이언트에 전송하는 단계를 포함하는 엔티티 태그 이용 방법.
137. 제136 항에 있어서,

     상기 시작 서버로부터 수신된 상기 응답은 엔티티 태그를 포함하지 않는 엔티티 태그 이용 방법.
138. 제136 항에 있어서,

     상기 캐시가 상기 동적으로 발생된 객체를 캐싱하기 위해 상기 클라이언트에 대한 지속 기간을 식별하도록 상기 응답을 수정하는 단계를 포함하는 엔티티 태그 이용 방법.
139. 제136 항에 있어서,

     상기 동적으로 발생된 객체가 상기 캐시 또는 상기 시작 서버 중 하나에 의해 변경되었는지를 체크한 후, 상기 캐시가 상기 응답을 저장하고 상기 응답을 서 빙할 것을 상기 클라이언트에 지시하기 위해 상기 응답을 수정하는 단계를 포함하는 엔티티 태그 이용 방법.
140. 제136 항에 있어서,

     상기 시작 서버로부터의 응답은 상기 동적으로 발생된 객체에 대한 캐시 제어 정보를 갖고 있지 않고, 상기 캐시는 캐시 제어 정보를 포함하도록 상기 클라이언트에 전송된 응답을 수정하는 엔티티 태그 이용 방법.
141. 제136 항에 있어서,

     상기 캐시가 상기 엔티티 태그에 대한 번호를 발생하는 단계를 포함하는 엔티티 태그 이용 방법.
142. 제136 항에 있어서,

     상기 캐시가 상기 발생된 엔티티 태그를 상기 동적으로 발생된 객체와 함께 저장하는 단계를 포함하는 엔티티 태그 이용 방법.
143. 제142 항에 있어서,

     상기 캐시가 캐시 제어 정보를 상기 동적으로 발생된 객체와 함께 저장하는 단계를 포함하는 엔티티 태그 이용 방법.
144. 제143 항에 있어서,

     상기 캐시가 상기 캐싱된 동적으로 발생된 객체를 상기 발생된 엔티티 태그 및 캐시 제어 정보와 함께 서빙하는 단계를 포함하는 엔티티 태그 이용 방법.
145. 제136 항에 있어서,

     어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 중 하나 상에서 상기 캐시를 동작시키는 단계를 포함하는 엔티티 태그 이용 방법.
146. 제136 항에 있어서,

     상기 요청 또는 상기 응답 중 하나는 HTML(HyperText Markup Language)를 포함하는 엔티티 태그 이용 방법.
147. 제146 항에 있어서,

     상기 캐시가 상기 발생된 엔티티 태그를 식별하는 이태그(etag) 헤더를 포함하도록 상기 응답을 수정하는 단계를 포함하는 엔티티 태그 이용 방법.
148. 제146 항에 있어서,

     상기 캐시가 캐시-제어 헤더를 포함하도록 상기 응답을 수정하는 단계를 포함하는 엔티티 태그 이용 방법.
149. 제146 항에 있어서,

     상기 캐시가 상기 클라이언트로부터 If-None-Match 헤더를 가진 제2 요청을 수신하는 단계; 및

     제2 요청에 응답하여, 상기 If-None-Match 헤더와 연관된 상기 이태그 값을, 상기 동적으로 발생된 객체와 함께 상기 캐시에 저장된 상기 엔티티 태그와 비교하는 단계를 포함하는 엔티티 태그 이용 방법.
150. 제149 항에 있어서,

     상기 이태그 값이 상기 엔티티 태그와 일치하면, 상기 캐시가 상기 제2 요청에 대한 수정되지 않은 응답을 상기 클라이언트에 전송하는 단계를 포함하는 엔티티 태그 이용 방법.
151. 제149 항에 있어서,

     상기 이태그 값이 상기 엔티티 태그와 일치하지 않으면, 상기 캐시가 갱신된 동적으로 발생된 객체를 제2 엔티티 태그와 함께 상기 클라이언트에 전송하는 단계를 포함하는 엔티티 태그 이용 방법.
152. 캐싱 불가능한 것으로 식별되는 동적으로 발생된 객체를 캐싱하기 위한 엔티티 태그 이용 시스템에 있어서,

     캐시에 의해, 동적으로 발생된 객체에 대한 클라이언트의 요청에 대한 응답 을 시작 서버로부터 수신하되, 상기 동적으로 발생된 객체는 캐싱 불가능한 것으로 식별된 수단;

     상기 캐시에 의해, 상기 캐시에 저장된 상기 동적으로 발생된 객체에 대한 엔티티 태그를 발생하는 수단;

     상기 캐시에 의해, 상기 발생된 엔티티 태그를 포함하도록 상기 응답을 수정하는 수단; 및

     상기 캐시에 의해, 상기 동적으로 발생된 객체를 캐싱 가능으로 식별하는 상기 수정된 응답을 상기 클라이언트에 전송하는 수단을 포함하는 엔티티 태그 이용 시스템.
153. 제152 항에 있어서,

     상기 시작 서버로부터 수신된 상기 응답은 엔티티 태그를 포함하지 않는 엔티티 태그 이용 시스템.
154. 제152 항에 있어서,

     상기 캐시에 의해, 상기 동적으로 발생된 객체를 캐싱하기 위해 상기 클라이언트에 대한 지속 기간을 식별하도록 상기 응답을 수정하는 수단을 포함하는 엔티티 태그 이용 시스템.
155. 제152 항에 있어서,

     상기 동적으로 발생된 객체가 상기 캐시 또는 상기 시작 서버 중 하나에 의해 변경되었는지를 체크한 후, 상기 캐시에 의해, 상기 응답을 저장하고 상기 응답을 서빙할 것을 상기 클라이언트에 지시하기 위해 상기 응답을 수정하는 수단을 포함하는 엔티티 태그 이용 시스템.
156. 제152 항에 있어서,

     상기 시작 서버로부터의 응답은 상기 동적으로 발생된 객체에 대한 캐시 제어 정보를 갖고 있지 않고, 상기 캐시는 캐시 제어 정보를 포함하도록 상기 클라이언트에 전송된 응답을 수정하는 엔티티 태그 이용 시스템.
157. 제152 항에 있어서,

     상기 캐시에 의해, 상기 엔티티 태그에 대한 번호를 발생하는 수단을 포함하는 엔티티 태그 이용 시스템.
158. 제152 항에 있어서,

     상기 캐시에 의해, 상기 발생된 엔티티 태그를 상기 동적으로 발생된 객체와 함께 저장하는 수단을 포함하는 엔티티 태그 이용 시스템.
159. 제152 항에 있어서,

     상기 캐시에 의해, 캐시 제어 정보를 상기 동적으로 발생된 객체와 함께 저 장하는 수단을 포함하는 엔티티 태그 이용 시스템.
160. 제159 항에 있어서,

     상기 캐시에 의해, 상기 캐싱된 동적으로 발생된 객체를 상기 발생된 엔티티 태그 및 캐시 제어 정보와 함께 서빙하는 수단을 포함하는 엔티티 태그 이용 시스템.
161. 제152 항에 있어서,

     어플라이언스, 네트워크 장치 또는 컴퓨팅 장치 중 하나 상에서 상기 캐시를 동작시키는 수단을 포함하는 엔티티 태그 이용 시스템.
162. 제152 항에 있어서,

     상기 요청 또는 상기 응답 중 하나는 HTML(HyperText Markup Language)를 포함하는 엔티티 태그 이용 시스템.
163. 제162 항에 있어서,

     상기 캐시에 의해, 상기 발생된 엔티티 태그를 식별하는 이태그 헤더를 포함하도록 상기 응답을 수정하는 수단을 포함하는 엔티티 태그 이용 시스템.
164. 제162 항에 있어서,

     상기 캐시에 의해, 캐시-제어 헤더를 포함하도록 상기 응답을 수정하는 수단을 포함하는 엔티티 태그 이용 시스템.
165. 제164 항에 있어서,

     상기 캐시에 의해, 상기 클라이언트로부터 If-None-Match 헤더를 가진 제2 요청을 수신하고, 제2 요청에 응답하여, 상기 If-None-Match 헤더와 연관된 상기 이태그 값을, 상기 동적으로 발생된 객체와 함께 상기 캐시에 저장된 상기 엔티티 태그와 비교하는 수단을 포함하는 엔티티 태그 이용 시스템.
166. 제165 항에 있어서,

     상기 이태그 값이 상기 엔티티 태그와 일치하면, 상기 캐시에 의해, 상기 제2 요청에 대한 수정되지 않은 응답을 상기 클라이언트에 전송하는 수단을 포함하는 엔티티 태그 이용 시스템.
167. 제165 항에 있어서,

     상기 이태그 값이 상기 엔티티 태그와 일치하지 않으면, 상기 캐시에 의해, 갱신된 동적으로 발생된 객체를 제2 엔티티 태그와 함께 상기 클라이언트에 전송하는 수단을 포함하는 엔티티 태그 이용 시스템.

Images