US20130103704A1 - Javascript reductor - Google Patents

Abstract

A system can be provided for dynamically serving a content file. A content object request function can receive a request for a webpage defined by the content file, the content file including a plurality of embedded or referenced content objects, at least one of the plurality of content objects including a Javascript. A content-file modifier can modify the content file to include instructions to generate reports comprising information relating to invocation of stubs. A report receiver can receive reports from the end user system, and an object usage analyzer quantifes usage of each of the stubs. An object prioritizor can prioritize the plurality of content objects based on the analysis, the prioritization including an identification of at least one high-priority content object. An object injector can modify the content file such that the high-priority content object automatically loads upon rendering of the content file.

Description

CROSS-REFERENCES TO RELATED APPLICATIONS
• This application is a continuation of U.S. Ser. No. 13/482,249, filed May 29, 2012 and entitled, “JAVA SCRIPT REDUCTOR”. This reference is hereby incorporated by reference in its entirety for all purposes.
BACKGROUND
• This disclosure relates in general to responding to content requests and, but not by way of limitation, to requests for content files with embedded or referenced content objects.
• Many webpages are embedded with various content objects, such as Javascript scripts, Flash animations, images, etc. When a webpage is requested, frequently, all embedded content objects are collected. This ensures that a webpage is appropriately rendered. However, such collection efforts may delay the time at which the webpage may be presented.
SUMMARY
• In one embodiment, the present disclosure provides a system and method for delivering content objects over the Internet to an end user system. A request for a content file (e.g., for a HyperText Markup Language file defining a webpage) may be received from an end user system. The requested content file may be accessed and modified, such that content objects (e.g., Javascript functions) embedded or referenced within the content file are replaced by stubs, and reporting instructions are injected into the code. When a stub is invoked, the associated content object is accessed and a report is generated identifying the stub access. Based on one or more of these reports, content objects associated with a content file are prioritized. Various techniques may be implemented to improve the speed at which high-priority content objects are available to users.
• In some embodiments, code or links for high-priority content objects are re-injected into the code (replacing or negating functionality of the corresponding stub). Thus, these content objects may be accessed quickly, and rendering speed is improved by not transmitting low-priority content objects. Meanwhile, low-priority content objects remain accessible via the stubs. In some embodiments, high-priority content objects are collected and cached (e.g., at an edge server of an CDN), such that they are quickly retrievable.
• In some embodiments, content objects are grouped into containers, and transmission of the container data is automatically initiated upon receiving a request for the associated content file. Thus, a webpage may be initially rendered, and an increasing number of embedded or referenced content objects may be transmitted to an end user system. Content objects may be ordered within a container, such that high-priority content objects are the firs to be transmitted. Prioritization of content objects may be applied to content objects of a variety of types. Thus, e.g., it is possible to determine a priority of a Javascript relative to an image object. Content objects of various types may thus be included in a single container and transmitted in an order based on this inter-type prioritization.
• In some embodiments of the invention, a system is provided for dynamically serving a content file with embedded or referenced content objects over the Internet to an end user system. A content object request function receives a request, from the end user system, for a webpage defined by the content file, the content file including a plurality of embedded or referenced content objects, at least one of the plurality of content objects including a Javascript. A content-file modifier modifies the content file. The content-file modifier includes a reporting-code injector that injects a reporting code into the content file, the reporting code including instructions to generate one or more reports including information relating to invocation of stubs. The content-file modifier further includes a content-file parser that identifies each content object of the plurality of content objects embedded or referenced in the content file and a stub controller that replaces each of at least two of the identified content objects with a stub, wherein the stub requests the identified content object from a remote source upon invocation of the stub. A report receiver receives reports generated in response to implementation of the reporting code in the modified content file. An object usage analyzer dynamically analyzes the received reports to quantify usage of each of the stubs. An object prioritizor prioritizes, in real time, at least two content objects of the plurality of content objects based at least partly on the dynamic analysis of the received reports, the prioritization including an identification of at least one high-priority content object. An object injector modifies, in real-time, the content file such that the high-priority content object automatically loads upon rendering of the content file.
• In some embodiments, a system is provided for dynamically serving content files with embedded or referenced content objects over the Internet to an end user system. A content object request function receives a request, from the end user system, for one or more content files, the one or more content files embedding or referencing a plurality of content objects, at least one of the plurality of content objects including a Javascript. A content-file transmitter transmits a modified version of the one or more content file in response to the request, from the end user system, for the one or more content files. The modified version of the one or more content files includes a plurality of stubs, each stub being associated with a content object of the plurality of content objects. Each stub requests the associated content object from a remote source upon invocation of the stub. An object usage analyzer dynamically generates statistics identifying frequencies of invocations of the stubs. An object prioritizor assigns priorities to the content objects associated with the plurality of stubs in real time, the assigned priorities being based at least partly on the statistics dynamically generated by the object usage analyzer that identifies the frequencies of invocations of the stubs.
• In some embodiments, a method is provided for dynamically serving content files with embedded or referenced content objects over the Internet to an end user system. A request is received, from the end user system, for one or more content files, the one or more content files embedding or referencing a plurality of content objects. At least one of the plurality of content objects includes a Javascript. A modified version of the one or more content file is transmitted in response to the request, from the end user system, for the one or more content files. The modified version of the one or more content files includes a plurality of stubs, each stub being associated with a content object of the plurality of content objects. Each stub requests the associated content object from a remote source upon invocation of the stub. Statistics are dynamically generated, the statistics identifying frequencies of invocations of the stubs. Priorities are assigned to the content objects associated with the plurality of stubs in real time, the assigned priorities being based at least partly on the statistics dynamically generated by the object usage analyzer that identifies the frequencies of invocations of the stubs.
• Further areas of applicability of the present disclosure will become apparent from the detailed description provided hereinafter. It should be understood that the detailed description and specific examples, while indicating various embodiments, are intended for purposes of illustration only and are not intended to necessarily limit the scope of the disclosure.
BRIEF DESCRIPTION OF THE DRAWINGS
• The present disclosure is described in conjunction with the appended figures:
• FIG. 1 depicts a block diagram of an embodiment of a content distribution system;
• FIG. 2 depicts block diagrams of embodiments of a content delivery network (CDN) coupled to the Internet;
• FIG. 3 depicts a block diagram of an embodiment of content-modifying system;
• FIG. 4 illustrates a flowchart of an embodiment of a process for generating a modified content file;
• FIG. 5 illustrates a flowchart of an embodiment of a process for accessing content;
• FIG. 6 depicts a block diagram of an embodiment of an object-delivery system;
• FIGS. 7aand7billustrate flowcharts of embodiments for prioritizing content objects;
• FIG. 8 depicts a block diagram of an embodiment of components of the delivery controller;
• FIG. 9 illustrates a flowchart of an embodiment of a process for delivering content objects;
• FIG. 10 illustrates a flowchart of an embodiment of a process for determining a container property;
• FIG. 11 depicts a block diagram of an embodiment of a computer system; and
• FIG. 12 depicts a block diagram of an embodiment of a special-purpose computer.
• In the appended figures, similar components and/or features may have the same reference label. Further, various components of the same type may be distinguished by following the reference label by a dash and a second label that distinguishes among the similar components. If only the first reference label is used in the specification, the description is applicable to any one of the similar components having the same first reference label irrespective of the second reference label.
DETAILED DESCRIPTION
• The ensuing description provides preferred exemplary embodiment(s) only, and is not intended to limit the scope, applicability or configuration of the disclosure. Rather, the ensuing description of the preferred exemplary embodiment(s) will provide those skilled in the art with an enabling description for implementing a preferred exemplary embodiment of the disclosure. It should be understood that various changes may be made in the function and arrangement of elements without departing from the spirit and scope of the invention as set forth in the appended claims.
• In one embodiment, the present disclosure provides a system and method for delivering content objects over the Internet to an end user system. A request for a content file (e.g., for a HyperText Markup Language file defining a webpage) may be received from an end user system. The requested content file may be accessed and modified, such that content objects (e.g., Javascript functions) referenced or embedded within the content file are replaced by stubs, and reporting instructions are injected into the code. When a stub is invoked, the associated content object is accessed and a report is generated identifying the stub access. Based on one or more of these reports, content objects associated with a content file are prioritized. Various techniques may be implemented to improve the speed at which high-priority content objects are available to users.
• In some embodiments, code or links for high-priority content objects are re-injected into the code (replacing or negating functionality of the corresponding stub). Thus, these content objects may be accessed quickly, and rendering speed is improved by not transmitting low-priority content objects. Meanwhile, low-priority content objects remain accessible via the stubs. In some embodiments, high-priority content objects are collected and cached (e.g., at an edge server of an CDN), such that they are quickly retrievable.
• In some embodiments, content objects are grouped into containers, and transmission of the container data is automatically initiated upon receiving a request for the associated content file. Thus, a webpage may be initially rendered, and an increasing number of embedded or referenced content objects may be transmitted to an end user system. Content objects may be ordered within a container, such that high-priority content objects are the first to be transmitted. Prioritization of content objects may be applied to content objects of a variety of types. Thus, e.g., it is possible to determine a priority of a Javascript relative to an image. Content objects of various types may thus be included in a single container and transmitted in an order based on this inter-type prioritization.
• Referring first toFIG. 1, a block diagram of an embodiment of acontent distribution system100 is shown where acontent originator106 offloads delivery of the content objects to a content delivery network (CDN)110. In this embodiment, thecontent distribution system100 can dynamically and efficiently serve objects (e.g., Javascript scripts, images, videos, Flash animations, etc.) over theInternet104 toend user systems102 by determining usage patterns and differentially providing objects in view of the patterns. For example, objects generally used frequently or quickly after loading a webpage may be provided to users before objects generally used less frequently and/or later. As another example, objects used frequently may be automatically provided after a request for an associated webpage, whereas objects used infrequently may be provided only upon subsequent request for the object. In this way, frequently and/or quickly accessed objects are quickly provided to users and access to these objects is not slowed by transmitting objects accessed less frequently and/or accessed after a delay.
• In some embodiments,content distribution system100 may further dynamically and efficiently serve webpage-code portions, style sheet portions, or style sheets (e.g., a Cascading Style Sheet). For example, a webpage code (e.g., an HTML code) may be reorganized such that code producing webpage portions first used or viewed are presented immediately or towards a top of a code and other portions are embedded into the webpage, served subsequently and/or towards a bottom of a code. As another example, style sheets affecting a first-used or first-viewed portion of a webpage may be quickly available to a user system, and other style sheets may be subsequently provided. Thus, embodiments that relate to determining how quickly a content object is used or viewed and improving the probability that quickly used or viewed content objects are quickly available to user systems may be extended to HTML code portions, HTML codes, style sheet portions, and style sheets.
• An end user may request a set of content object, e.g., by requesting a webpage associated with the set of content objects. For example, a user may request a file, such as a Hypertext Markup Language (HTML) file. The requested file may include multiple code portions, calls to multiple style sheets, and/or code that references or embed sa plurality of objects (e.g., including content objects, HTML code, etc.). For example, the file may include tags and code to embed an internal or external object (e.g., a Javascript function) or libraries of objects into the file. A source of each of the content objects and/or the file may be on an edge server or any other server within the CDN.
• If an end user system retrieves all of the embedded and referenced objects before responding to the user's request, the response may be relatively slow and a substantial amount of bandwidth may be consumed. However, if an end user system does not retrieve all of the embedded and referenced objects before responding to the user's request, an object may be unavailable to display or run at an appropriate time. Thus, as described in greater detail below, embodiments of the present invention relate to differentially and/or selectively hastening the providing of embedded and referenced objects to an end user system based on predicted usage of the objects.
• Acontent originator106 produces and/or distributes content objects as the originator of content in a digital form for distribution with theInternet104. Included in thecontent originator106 are acontent provider108, acontent site116 and an origin server112. The figure shows a single origin server112, but it is to be understood embodiments could have multiple origin servers112 that each can serve streams of the content object redundantly. For example, thecontent originator106 could have multiple origin servers112 and assign any number of them to serve the content object.
• Although, this figure only shows asingle content originator106 and a single CDN110, there may be many of each in other embodiments. The content object is any content file or content stream and could include, for example, video, pictures, advertisements, script, data, audio, software, and/or text. The content object could be live, delayed or stored. Throughout the specification, references may be made to a content object, content, and/or content file, but it is to be understood that those terms could be generally used interchangeably wherever they may appear.
• Many content providers108 use the CDN110 to deliver the content objects over theInternet104 to end users128. When a content object is requested by an end user128, the CDN110 may retrieve the content object from thecontent provider108. Alternatively, thecontent provider108 may directly provide the content object to the CDN110, i.e., in advance of the first request or in servicing the first request. In this embodiment, the content objects are provided to the CDN110 through caching and/or pre-population algorithms and stored in one or more servers such that requests may be served from the CDN110. The origin server112 holds a copy of each content object for thecontent originator106. Periodically, the contents of the origin server112 may be reconciled with the CDNs110 through a cache and/or pre-population algorithm. Some embodiments could populate the CDN110 with content objects without having an accessible origin server such that the CDN serves as the origin server, a host or a mirror.
• The CDN110 includes a number of points of presence (POPs)120, which are geographically distributed through thecontent distribution system100. Various embodiments may have any number ofPOPs120 within the CDN110 that are generally distributed in various locations around theInternet104 to be proximate, in a network quality of service (QoS) sense, toend user systems102. A wide area network (WAN)114 or other backbone may couple thePOPs120 with each other and also couple thePOPs120 with other parts of the CDN110. Other embodiments could couplePOPs120 together with the Internet optionally using encrypted tunneling.
• When an end user128 requests a content link through its respectiveend user system102, the request for the content is passed either directly or indirectly via theInternet104 to thecontent originator106. The request for content, for example, could be an HTTP Get command sent to an IP address of thecontent originator106 after a look-up that finds the IP address. Thecontent originator106 is the source or re-distributor of content objects. Thecontent site116 is accessed through acontent web site116 in this embodiment by theend user system102. In one embodiment, thecontent site116 could be a web site where the content is viewable by a web browser. In other embodiments, thecontent site116 could be accessible with application software other than a web browser. Thecontent provider108 can redirect content requests to any CDN110 after they are made or can formulate the delivery path beforehand when the web page is formulated to point to the CDN110. In any event, the request for content is handed over to the CDN110 for fulfillment in this embodiment.
• Once the request for content is passed to the CDN110, the request is associated with aparticular POP120 within the CDN110. A routing algorithm used to choose betweendifferent POPs120 could be based upon efficiency, randomness, and/or proximity in Internet terms, defined by the fabric of the Internet and/or some other mechanism. Theparticular POP120 then assigns or routes the request to an edge server. Theparticular POP120 may retrieve the portion of the content object from thecontent provider108. Alternatively, thecontent provider108 may directly provide the content object to the CDN110 and its associatedPOPs120, i.e., in advance of the first request. In this embodiment, the content objects are provided to the CDN110 and stored in one or more CDN servers such that the portion of the requested content may be served from the CDN110. The origin server112 holds one copy of each content object for thecontent originator106. Periodically, the content of the origin server112 may be reconciled with the CDN110 through a cache, hosting and/or pre-population algorithm.
• An edge server serving the request may access the requested content—either by locally retrieving part or all of the content or requesting it from another server. In some instances, the edge server determines a source for part or all of the requested content within the CDN110 by querying other peer servers within or remote from theparticular POP120. This embodiment dynamically discovers peer servers, which have already cached or stored the requested content. The peer server that already holds the requested content could be an edge server or a server that doesn't service end user requests, for example, a relay server or ingest server. If part or all of the content cannot be found in thePOP120 originally receiving the request, neighboringPOPs120 could serve as the source in some cases, or the content could be sourced from thecontent originator106.
• Thus, a request from anend user system102 for content may result in requests for content from one or more servers in the CDN110. A CDN server (e.g., an edge server, peer servers, an origin server, etc.) may analyze requested content objects (e.g., requested HTML files), modify the requested content objects (e.g., to include reporting instructions, HTML stub wrappers, etc.), and transmit the modified requested content objects in response to the requests.
• Theend user system102 processes the content for the end user128 upon receipt of the content object. Theend user system102 could be a personal computer, media player, handheld computer Internet appliance, phone, IPTV set top, streaming radio or any other device that can receive and play content objects. In some embodiments, a number ofend user systems102 can be networked together sharing a single connection to theInternet104. Although this embodiment only shows asingle content originator106 and a single CDN110, it is to be understood that there could be many of each in various embodiments.
• Referring next toFIG. 2, a block diagram of an embodiment of the CDN110-1 is shown coupled to theInternet104 with additional detail for one of thePOPs120. EachPOP120 may include acontent request interface220, a server selection function224, adelivery interface226, a number of CDN edge servers230, and other servers (not shown). For simplicity, this embodiment only shows threePOPs120 within the CDN110, however any number of POPs may exist in various embodiments.
• As explained above in relation toFIG. 1, when a request for content is handed over to the CDN110, the request is associated with aparticular POP120 within the CDN110 using any number of algorithms. For example, the assignment could be round-robin, random, based upon loading of the edge server, distance between POP and end user, and/or other algorithms. Theparticular POP120 receives the request through acontent request interface220 and distributes the request to the server selection function224. The server selection function224 assigns the request for content to an edge server230 to stream the content object to theend user system102. The server selection function224 selects the edge server230 from a group of edge servers230 in thePOP120. A number of algorithms can be used to assign the request to an edge server230. For example, the server selection function224 may use routing algorithms, domain name service (DNS) resolution or an HTTP-redirect to direct a particularend user system102 to a particular edge server230.
• Various parameters may be taken into account for selection of the edge server230. Examples of parameters influencing selection of the particular edge server may include content object characteristics, server assignment to a particular content provider, adequate quality of service (QoS), performance metrics, capabilities of the edge server230, and/or routing efficiency between the edge server230 andend user system102. Embodiments could have any number of edge servers230 within eachPOP120 of the CDN110.
• When the request for content is assigned to the edge server230, the edge server230 may determine a source for part of all of the requested object (e.g., a content file and/or embedded or referenced content objects). The content source(s) may be determined using one or more techniques. For example, a publishing point mapping content to one or more paths where the content can be found may be identified and/or a peer-discovery algorithm may be implemented. In some embodiments, a content source may be determined by, e.g., querying a content registrar or distributed registrar. The content registrar may receive reports from edge servers in a plurality of POPs, and the distributed registrar may receive reports from edge servers in a particular POP. One or both registrars may be queried to identify where content is stored within the CDN. The content source(s) may include, e.g., the edge server230 itself, a peer server or thecontent provider108 or any other server with the content.
• Some embodiments select one of the edge servers230 to serve a particular content object for all requests in thePOP120. Where the edge server230 receiving the request serves the content from a source external to its POP, like thecontent provider108 or anotherPOP120, the edge server230 would become the master for itsPOP120 such that other edge servers230 in the same POP would use the master edge server230 found during peer discovery rather than getting the content externally. Other edge servers230 receiving a request for the content object would find the master edge server230 using peer discovery.
• Although this embodiment chooses a single edge server230 other embodiments could assign the same content object request to multiple edge servers230 on different occasions. To balance the load, for example, a variable number of edge servers230 could be selected for a particular request such that they shared the delivery load. An edge server230 without a particular content object could act as a relay to get the content object from a peer or neighboring edge server. The number of relay edge servers for a group of content object requests is configurable based on a number of factors, for example, stream name, customer name, service type, customer preference, number of edge servers, loading of edge servers, etc.
• Referring next toFIG. 3, a block diagram of an embodiment of content-modifyingsystem300 is shown. Any of a variety of components in thecontent distribution system100 may include and/or be coupled to the content-modifyingsystem300. For example, in some instances, a content-modifyingsystem300 is implemented by one, more or each of a plurality of edge servers230 (e.g., that respond to requests from users128) at one, more or each of a plurality ofPOPs120. Other implementations are possible. For example, the content-modifyingsystem300 may be implemented by the origin server(s)112, by one or more end user system(s)102, by a server coupled to a plurality of edge servers230 (e.g., at a POP), by a server coupled to a plurality ofPOPs120, etc. In some instance, thecontent distribution system100 includes a plurality of content-modifying systems, which may or may not be located in parallel locations (e.g., at a plurality of edge servers or at an edge server and at an origin server).
• Content-modifyingsystem300 includes a content-file receiver310. Content-file receiver receives a content file. In some instances, content-file receiver310 requests the content file (e.g., from an origin server) and receives the content file in response to the request. The content-file receiver310 may request the content file, e.g., upon detecting a request for the file and/or determining that the requested content file is not stored in a content-files database320. A “content file”, as used herein, may refer to a single file or a set of files. For example, a single HTML file may call or include additional files (e.g., style-sheet files and HTML files). A “content file” may thus, e.g., include all (e.g., markup and/or style-sheet) files included and cooperating to render content.
• In some instances, content-file receiver310 receives the content file by intercepting the content file while the content file is being transmitted to another location. Thus, for example, an edge server230 may have requested the content file from an origin server, and a content-file receiver310 of a content-modifyingsystem300 separate from the edge server230 may detect a response to the request and intercept the content file.
• In some instances, a content file is accessed from the content-file database320. The content-file database320 may include original and/or modified content files. Original and/or modified content files may be associated with storage locations, naming conventions, associated identifiers (e.g., in the content file or in an index of content files), etc. in order to convey a modification status. The content-file database320 may or may not be stored locally with respect to the content-file modifier330. In some instances, one or more content-file databases320 are located at each of a plurality of edge servers.
• The content file may include a file written in a markup language (e.g., HTML) and/or a style-sheet language (e.g., Cascading Style Sheets). The content file may include one or more embedded or referenced content objects.
• A content-file modifier330 modifies a content file (accessed via the content-file receiver or the content-file database320). The content file may comprise a code, such as a code written in a markup language (e.g., HTML). The content file may be modified prior to a compiling of the content file. The content file may comprise a single file or a set of files. The content file may comprise a webpage-defining file.
• The content-file modifier includes a reporting-code injector332, which injects a reporting code into the content file. The reporting code may include a reporting destination, reporting conditions and/or reporting protocols. For example, the reporting code may include instructions to send a report each time or a first time that a particular function is called, a type of function is called, specific/general content identified in the content file is retrieved from an external source, etc. Reporting protocols may include a requested frequency of reports. For example, reports may be sent every time one, more, a set or a threshold number of conditions are fulfilled; at fixed intervals but only when one, more, a set or a threshold number of conditions are fulfilled; at fixed intervals irrespective of condition fulfillment; etc. The reporting code may be injected, e.g., towards a beginning of the content file, near calls to functions, near embedded or referenced objects, etc.
• The content-file modifier330 includes a content-file parser334, which parses the content file to identify one or more objects (e.g., embedded content objects, referenced content objects, code portions, included style sheets, etc.). For example, the content-file parser334 may identify embedded Javascript scripts (e.g., by scanning for script tags), Flash animations, images, embedded links, etc. The objects may comprise, e.g., objects internal to the content file, external to the content file but associated with a same domain name as the content file (e.g., a link to a local image), or external to the content file and a hosting server.
• The content-file parser334 may communicate with astub controller336. Operations of the content-file parser334 may be sequential (e.g., the content-file parser334 first identifying all objects and thestub controller336 then generating and/or injecting stubs) or not (e.g., the content-file parser334 identifying one or a subset of objects, thestub controller336 generating and/or injecting stubs for the identified objects, the content-file parser334 identifying another or another subset of objects, etc.).
• After an content-file object is identified by the content-file parser334, thestub controller336 injects a stub into the content file or modifies an existing stub in the content file for the identified object. As used herein, a stub comprises a local piece of code that, when implemented, forwards a request for an object to a server and receive a response to the request. Thus, for example, a stub may request implementation of a remote Javascript, receive the response, and present the response to a requesting user via, e.g., a webpage defined by the content file. As another example, a stub may request an image from a remote source, download the requested image, and present the image to a requesting user via, e.g., a webpage defined by the content file. A stub can be associated with (e.g., replace or represent), e.g., a whole script file, a part of a script file, one function, multiple functions, a part of a function, one object, or a part of an object.
• Implementing the stub, therefore, comprises accessing a remote resource (e.g., using a remote Javascript script, accessing a remote image file, etc.) and presenting either the remote resource or a result of the remote resource to a user. Thus, the user is unaware that the resource is remote and there is little to no functional content consequence of using a stub. However, because the accessed resource is remote, using a stub may delay presentations of content to a user.
• The stub may be configured to marshal data (e.g., parameters passed to a remote server) and/or unmarshal data (e.g., in a received response to the request). The stub may comprise a Javascript. The stub may be in communication with a skeleton which retrieves the requested object and transmit the requested object to the stub.
• In some instances, one, more or all stubs comprise or are associated with a reporting feature. For example, the stub may include a piece of code which automatically transmits a report when the stub is called. As another example, the stub may be associated with a skeleton that transmits a report when the skeleton is called. In some instances, reporting features are not specifically integrated into a stub and/or skeleton, but the reporting code injected by the reporting-code injector332 may determine when specific stubs or stubs generally were called and report such calls.
• In some instances, the injected reporting code or “null” stubs serve to identify when particular content objects are viewed or executed, but no request is sent for the content object. For example, a “null” stub or marker may be associated various HTML portions of a webpage code. When a user views or uses an associated webpage portion, a report may be generated and transmitted.
• Thestub controller336 comprises astub generator338 configured to generate one or more stubs. In some instances, one stub is associated with each content object, or each content object of a particular type (e.g., a Javascript, image, HTML portion, etc.) identified by the content-file parser. Thestub generator338 may generate a stub, e.g., by generating another object (e.g., Javascript). In some instances, thestub generator338 may further be configured to generate code to display placeholder content (e.g., stored locally) while the stub is collecting the requested content. For example, a placeholder small image file may be generated and/or associated with one or more content objects.
• Thestub controller336 further includes astub injector340. Thestub injector340 injects the generated code into the content file. Injecting the stub may include replacing a portion of the content file with the stub. For example, a function in the content file may be replaced with a stub. In some instances, injecting a stub comprises injecting and/or modifying code in one or more files other than the content file. For example, a skeleton code corresponding to a stub may be generated to be stored in another file and/or at another server.
• The modified content file may be stored, e.g., in a content-file database (such as content-file database320) at an end user system, at a POP, at an edge server, at an origin server, etc. The modified content file may be stored in a local or remote location. For example, an edge server may comprise the content-modifyingsystem300 and the modified content file may be stored locally. As another example, a server between an origin server and an edge server may comprise the content-modifyingsystem300 and the modified content file may be stored at the edge server. In some instances, multiple versions of the modified content file are saved. For example, the modified content file may be generated at or near the origin server, and copies of the modified content file may then be stored at a plurality of (or each) POP within a CDN or at a plurality of (or each) edge server within a CDN. Copies may then be revised independently from each other and/or in a global manner.
• A content-file transmitter350 transmits the modified content file. The modified content file may be transmitted, e.g., to a POP, to an edge server, to an end user system, etc.
• With reference toFIG. 4, a flow diagram of an embodiment of aprocess400 for generating a modified content file is shown. The depicted portion of the process begins in step405 where the content-file modifier330 accesses one or more content files (e.g., received by the content-file receiver310 or accessed from a content-file database320). A determination is made, atblock410, as to whether the accessed content file is modified. For example, a determination may be made as to whether the content file comprises one or more usage-related reporting codes, whether one or more stubs are associated with the file, whether a modification identifier is associated with the file, etc. If the content file is modified, then the process continues to block435, and the modified file is transmitted by the content-file transmitter350 (e.g., to an edge server, end user system, etc.).
• If the content file is not modified, then processing continues to block415, at which reporting code is injected into the content file by the reporting-code injector332. The content-file parser334 parses the content file, at block420, to identify one or more content objects. Based on the identified content objects, astub generator338 generates one or more stubs for each identified object atblock425, and astub injector340 injects the stubs into the content file atblock430. Thus, the content file is modified to include one or more stubs that invoke remote resources and further include reporting functionality such that reports are generated and transmitted to indicate, e.g., which stubs are implemented and when they are implemented. The modified content file is then transmitted by the content-file transmitter350 (e.g., to an edge server, end user system, etc.) atblock435.
• With reference toFIG. 5, a flow diagram of an embodiment of aprocess500 for accessing content is shown. The depicted portion of the process begins instep505 where a content file (e.g., a webpage) is requested. For example, an user128 may enter a uniform resource locator (URL), click on a hypertext link, etc. The request may be transmitted, e.g., from anend user system102 associated with the user128 over a network (e.g., the Internet104) to aPOP120. The request may be assigned to an edge server230 at the POP.
• In response to the request, a modified content file may be received by anend user system102. For example, an edge server230 may receive and modify the requested content file in accordance withprocess400 depicted inFIG. 4 and transmit the file to theend user system102, or an origin server may access and modify the requested content file in accordance withprocess400 depicted inFIG. 4 and transmit the file to theend user system102 via an edge server. In some instances, theend user system102 receives an unmodified content file and itself modifies the file, e.g., in accordance withprocess400 depicted inFIG. 4.
• Atblock515, theend user system102 compiles at least part of the modified content file. At block520, a stub for a content object is invoked. For example, a user may attempt to interact with an applet or application, or a webpage may attempt to display an image. Atblock525, the stub invocation is reported. For example, the occurrence of the stub invocation, a time (e.g., relative to a request time, page-loading time, etc.) of the invocation, a result of the invocation (e.g., a response time), may be reported. In some instances, a report includes data about invocations of multiple stubs. Thus, generation and/or transmission of reports may be delayed, e.g., until a user has left a webpage.
• Atblock530, the stub requests the content object or a result from the content object. For example, the stub may request that a Javascript script compute a result based on user inputs, or the stub may request that the content object (e.g., an application or file) be delivered. The request may be sent, e.g., to a remote server, such as a server that provided the modified content file, an edge server, an origin server, etc. The request may be sent to a server that is within a same CDN as the requestingend user system102 or outside CDN of the requestinguser system102.
• In some instances,process500 does not include block520 and/or blocks530-535. For example, a reporting code in the modified content file may instruct theend user system102 to report use of a content object (e.g., viewing a webpage portion associated with an HTML code portion or viewing a webpage portion affected by a style sheet), or null stubs may be inserted to report the use of a content object. In these embodiments, the used or viewed content object may already be available toend user system102, such that it need not be requested.
• In some instances, the request is sent to a skeleton (on a remote server, such as an edge server serving the content-file request)) associated with the invoked stub. The skeleton may then obtain the requested content object or result from the content object (e.g., from an origin server or CDN-external source). Atblock535, the content object or result from the content object is received from the stub. The content object or the result from the content object may be presented to the user128. Blocks520-535 may be repeated as other stubs are invoked.
• Referring next toFIG. 6, a block diagram of an embodiment of an object-delivery system600 for is shown. Any of a variety of components in thecontent distribution system100 may include and/or be coupled to the object-delivery system600. For example, in some instances, an object-delivery system600 is implemented by each of a plurality of edge servers230 (e.g., that respond to requests from users128) at each of a plurality ofPOPs120. Other implementations are possible. For example, the object-delivery system600 may be implemented by the origin server(s)112, by one or more end user system(s)102, by a server coupled to a plurality of edge servers230 (e.g., at a POP), by a server coupled to a plurality ofPOPs120, etc. In some instance, thecontent distribution system100 includes a plurality of object-delivery systems600, which may or may not be located in parallel locations (e.g., at a plurality of edge servers or at an edge server and at an origin server).
• The object-delivery system600 includes areport receiver610, which receives reports regarding usage patterns as they pertain to one or more content files. The reports may indicate, e.g., requested and/or actual access to one or more content objects embedded or referenced in a content file, viewing a portion of a webpage affected by an HTML code portion or style sheet portion, and/or use of a stub associated with a content object. The reports may include, e.g., one or more time stamps, such as a time stamp associated with: a request for a content file, with receipt of the content file, display of a webpage associated with the content file to a user, use of a stub, a call made by a stub, a reply sent in response to a stub request, etc. The time stamp may include an absolute time or a relative time (e.g., relative to a time of a request for the content file). The reports may include details about an end-user system, such as a browser used to display content in the content file, an operating system, a type of device, etc. Reports may be received from one ormore users102 and/or end user systems128. In some embodiments, end user systems128 that were served the content file (or a modified version thereof) from an edge server or from an origin server (e.g., via an edge server) send reports to the edge server230 or to the origin server112. Reports may also be received from parallel or higher level network components. For example, areport receiver610 at a first edge server230-1 may receive reports from a second edge server230-2 (which may have received the reports from an end-user system102).
• Thus, in some instances, reports may be generated by and received (directly or indirectly) from end user systems128. In some instances, reports are additionally or alternatively generated by and received from other servers. For example, a skeleton residing on a server remote from an end user system may generate a report after being called by a corresponding stub or after responding to a call from a corresponding stub.
• The object-delivery system600 includes anobject usage analyzer620, which analyzes the reports received by thereport receiver610. For each of a plurality of content objects (e.g., each content object embedded or referenced in a content file, contributing to a content file, being called by a content file, associated with a stub in a modified version of the content file, etc.), theobject usage analyzer620 may determine whether, how frequently, when and/or how the content object was accessed.
• Anaccess detector622 may determine whether a content object associated with a content file was accessed generally or within a particular time period. Access to the content object may be in the received reports or may be inferred based on data in the reports. For example, theaccess detector622 may detect access to a content object when a stub associated with the content object requested a content object or a result from the content object.
• A usage time-stamp identifier624 may determine temporal information related to access of the content object. For example, the usage time-stamp identifier624 may identify an absolute time of access of a content object or a relative time of access of a content object (e.g., relative to a display of a corresponding webpage, request for the content file, etc.). The usage time-stamp identifier624 may identify an order of access to content objects. For example, a user may have accessedContent Object #1 first,Content Object #5 second, and Content Object #10 third.
• Outputs from theaccess detector622 and/or from the usage time-stamp identifier624 may be aggregated across reports by thedata aggregator626.Data aggregator626 may determine, e.g., outputs corresponding to a same or similar content file (e.g., being generated based on data from one or more reports) and aggregate the data. Thus, for example, the aggregated data may include data received from reports generated from a plurality of end user systems128. The data may be aggregated, e.g., in a cumulative manner or in a time-binned manner.
• One or more object usage statistics, stored in an object-usage-statistics database628, may be generated based on the aggregated data. The object usage statistics may or may not include variables specific to a same or similar content file (e.g., URL). The object usage statistics may be specific to content objects. The object usage statistics may indicate, e.g., a frequency at which a content object was accessed, information pertaining to a relative time at which the content object was accessed (e.g., a mean time of access with respect to a time of a request for an associated content file), dependencies on locality or end-user-system variables (e.g., browsers, edge server locations, etc.), etc.
• Based at least partly on the analysis performed by theobject usage analyzer620, anobject prioritizor630 then prioritizes content objects. The prioritization may include ranking at least two of the content objects, assigning the content objects to groups based on priorities, etc.
• In one instance, the prioritization comprises identifying one or more rarely-requested content objects. The rarely-requested content objects may comprise content objects associated with statistics identifying a low count of accesses and/or a low frequency of accesses. Thus, a count or frequency of access may be compared to an absolute threshold (e.g., identifying content objects requested fewer than 50 times or fewer than 50 times per month). A count or frequency of access may be compared to a relative threshold (e.g., identifying content objects for which access counts were less than 5% as compared to a maximum access count; identifying content objects for which access counts' contribution to a content-file's total access to count to all content objects was less than 1%, identifying content objects that were not amongst the top 20 most requested content objects, etc.). In one instance, the prioritization comprises determining which content objects are accessed quickly and which content objects are accessed after a delay.
• Generally, frequently requested content objects may be prioritized over rarely requested content objects, and quickly accessed content objects may be prioritized over content objects accessed after a delay. However, other factors may further influence prioritization, such as: size of content objects, bandwidth consumption of transmitting the content object, estimated download time associated with the content object, use of a content object in multiple content files, popularity of an associated content file, etc.
• In some instances, the prioritization depends at least partly on an actual or predicted location of one or more content objects within a webpage as rendered. For example, a reporting code in a modified content file may instruct an end user system to collect (in a raw or processed form) information about a location of one or more content objects (e.g., including those defined inside iframes) with respect to a rendered, e.g., webpage. The information may be transmitted in a raw or processed form to an as-renderedlocator632. The information may itself comprise location estimates or the as-renderedlocator632 may estimate locations based on the data. Objects may be prioritized at least in part based upon the estimated location (e.g., prioritizing objects based on their position with respect of the Y-axis, such that top-positioned objects are assigned relatively high priorities).
• The prioritization may be performed globally or for a particular set of data. For example, the prioritization may be specific to a content file (e.g., ranking content objects embedded or referenced in the content file), to a user characteristic (e.g., browser or user device), to a type of content object (e.g., Javascripts or images), etc. A location of the object-delivery system600 may further influence a specificity of the prioritization. For example, an object-delivery system600 located at an edge server and/or only receiving reports associated with one edge server may identify object prioritizations specific to the edge server. Thus, in some embodiments, multiple object-delivery systems600 may be included within a content-delivery system100, and multiple object prioritizations may be determined. In some instances, prioritization schemes vary across different prioritizations. For example, in some embodiments, prioritizations of images depend upon their as-rendered locations, while prioritizations of Javascripts do not.
• The object-delivery system600 may include an access improver634 to improve access to content objects assigned high priorities by theobject prioritizor630. In some instances, the access improver634 coordinates automatic loading of the content objects assigned a high priority and/or identifies an order for automatically loading of the content objects based upon priorities. Thus, if a request for a content file is received after a prioritization performed by theobject prioritizor630, content objects assigned high priorities (e.g., and predicted to be frequently used and/or used quickly) may be quickly or immediately available to a user following rendering, e.g., of a webpage. This may be accomplished by, e.g., revising a content file (e.g., to include a content object code), automatically transmitting another file and/or high-priority content objects in response to subsequent content-file requests, and/or coordinating automatic transmission of content objects via virtual containers to prioritize the high-priority content objects.
• In some instances, content files (e.g., stored in the content-file database320) are modified. For example, anobject injector638 may inject content objects (e.g., high-priority content objects) and/or code associated with the content objects (e.g., load instructions, direct links, local links, etc.) into the modified content files. Thus, accessing the high-priority content objects may be more direct and result in faster access. In some instances, stubs associated with at least some content objects are removed. For example, code may be inserted into the content file to automatically load a high-priority content object, and an associated stub may be removed. In some instances, stubs are not removed. A stub may, e.g., include conditional instructions, such that a content object is only requested if it has not already been loaded. Therefore, even if the stub remains in the file, it will not substantially affect the functionality of the code, as it will not request objects already available locally.
• As another example, a content file may be rearranged such that HTML-code content objects are ordered and/or segmented according to a priority. HTML code portions producing webpage portions viewed first may be associated with a high priority and pulled towards a top of an HTML code. HTML code portions producing infrequently viewed webpage portions may be associated with a low priority, and pushed towards a bottom of an HTML code or segmented into a separate HTML file called by the initial HTML code.
• In some instances, high priority objects are collected by anobject collector640. The collected content objects may be stored or cached, e.g., in a content-object database645. The content-object database645 may be located, e.g., at an edge server. Thus, requests for a content file may result in requests sent to fewer, e.g., origin servers, and the speed required to respond a request for the content object may be reduced.
• Adelivery controller650 may further generate and/or adapt one or more delivery protocols (e.g., stored in a delivery-protocol database655) to improve access to high-priority content objects. For example, high-priority content objects may be automatically transmitted to anend user system102 upon receiving a request for an associated content file. The automatically transmitted content objects may further be divided into multiple groups (to allow for multiple simultaneous transmissions) and/or ordered (e.g., within a group) to improve the quick availability of high-priority content objects. For example,FIGS. 8-9 and the related text describe embodiments related to grouping content objects into containers.
• With reference toFIG. 7a, a flow diagram of an embodiment of a process700afor prioritizing content objects is shown. The depicted portion of the process begins instep705 where a stub-invocation report is received by thereport receiver610. The stub-invocation report may include data identifying access to one or more content objects, associated with one or more files. The received report may include information about when the one or more content objects were accessed.
• Theaccess detector622 detects, atblock710, access of one or more content objects based on data in the received report. The usage time-stamp identifier624 identifies, atblock715, temporal features related to access of one or more content objects. Blocks705-715 may be repeated to accumulate data pertaining to a content file. Subsequently or simultaneously, atblock720, thedata aggregator626 aggregates the object-usage data (e.g., including detected access and/or identified temporal features) and generates usage statistics.
• Based at least in part on the generated usage statistics, theobject prioritizor630 prioritizes objects (e.g., associated with a particular content file or a group of content files, such as those served by an edge server) atblock725. Atblock730, an access improver634 improves (e.g., hastens) access to high-priority objects. The process700amay be repeated, such that objects are dynamically and frequently prioritized. Further the process700amay be performed in real-time or near real-time. Thus, no separate training period is necessary, and objects may be prioritized and access to objects adjusted nearly immediately after a content file is available over a network.
• With reference toFIG. 7b, a flow diagram of an embodiment of a process700bfor prioritizing content objects is shown. Many blocks parallel those inFIG. 7a, and pertinent related disclosures are contemplated for this embodiment as well.FIG. 7bshows examples of how access to high-priority objects may be improved atblock730 inFIG. 7a.
• At block750, a content file may be revised. For example, theobject injector638 may inject a high-priority content object and/or code associated with a high-priority content object (e.g., a Javascript function, a direct and/or local link, etc.) into a content file (e.g., and may or may not further replace a stub associated with the content object). As another example, a content file may be reorganized such that high-priority portions (e.g., file-portion content objects) or high-priority calls or towards a top of the content file. As another example, a content file may be segmented such that low-priority content objects (e.g., HTML code, a referenced object, or an embedded object) are reorganized into a separate code that is called by the revised content file.
• At block755, theobject collector640 may collect high-priority objects. The collected high-priority objects may be cached, atHock765, e.g., at a local server or edge server in a content-object database. As described in further detail below, the collected objects may be stored in or associated with virtual containers. Atblock770, thedelivery controller650 may control delivery of the content file and of content objects. For example, thedelivery controller650 may determine which content objects to transmit with the content file and/or to transmit automatically upon receiving a request for the content file. Thedelivery controller650 may further determine an order of transmission of content objects, a number of simultaneous downloads (of content objects) to initiate, compiling conditions, etc.
• Referring next toFIG. 8, a block diagram of an embodiment of components of thedelivery controller650 is shown. In this embodiment, thedelivery controller650 includes abandwidth predictor805 configured to predict available bandwidth between a source location e.g., comprising the content-object database645, and an end user system. The available bandwidth may be predicted by analyzing protocols, such as a Transmission Control Protocol, and limits associated with the protocol. The available bandwidth may be predicted based on, equations, transmissions of test objects, historical transmissions of non-test objects, etc.
• A container generator810 generates one or more virtual containers, which may be stored in a container database820. A virtual container acts to group a plurality of content objects together. Thus, all of the group objects may be transmitted in a single transmission. The container generator810 may identify a number of virtual containers to generate based at least partly on the prediction of an available bandwidth made by thebandwidth predictor805. The number of containers may further depend on size of content objects and prioritizations of content objects. For example, if it is of high importance to fully transmitContent Objects #1 and #2 very quickly, butContent Object #3 is of less importance, it may be advantageous to generate two—not three—containers.
• An object distributor815 distributes content objects amongst the generated containers. Distributing the containers may include determining which content objects are assigned to specific containers and further prioritizing and/or ordering content objects within a container. The distribution may depend upon prioritization of the content objects determined by thecontent prioritizor630. In some embodiments, containers are configured such that multiple containers will be simultaneously transmitted (e.g., to an end user system102). During the transmission of the container, content objects associated with a low rank (e.g., “1^st”) are transmitted prior to content objects associated with higher ranks. Thus, the object distributor815 may distribute the content objects such that high-priority content objects are distributed amongst the containers. This will allow for multiple high-priority content objects to be simultaneously transmitted over a network and to be quickly available to a user.
• In some instances, at least some containers include only content objects of a single type. For example, in one embodiment, at least one container only includes Javascript content objects and/or only includes image objects. In these instances, separate containers may or may not include different types of content objects. For example, all containers may only include Javascript content objects, or a first container may include only Javascript content objects and a second container may include only image content objects.
• In some instances, at least one container (or all containers) include or are configured to include content objects of a plurality of types. Thus, a single container may include, e.g., a Flash animation object, an image object, a style sheet, and a Javascript. Embodiments disclosed herein further allow for prioritization of content objects across a plurality of types. Thus, it is possible to determine whether a particular Javascript should receive a higher priority than a particular image object. This prioritization may be based at least partly on analyzing a frequency and/or timing of actual use of these objects.
• In some instances, a container property (e.g., a number of containers, a distribution of content objects amongst the containers, which or how many content objects are distributed amongst the containers, etc.) is based on an analysis performed by a container-assignment analyzer830. The container-assignment analyzer830 analyzes a plurality of possible container assignment configurations. Each possible container assignment configuration may include a number of containers, and an assignment of each of a plurality of content objects to one of the containers. The container-assignment analyzer may estimate transmission properties associated with each assignment configuration.
• The container-assignment analyzer830 includes acontainerizing sample generator835 that generates a plurality of sample. Each sample includes a different container assignment configuration. Thus, one or more of the number of containers, container-assignment algorithms, number of assigned content objects and identity of assigned content objects may vary across the samples. For example, a first sample may include assigningContent Objects #1, #3 and #5 toContainer #1 and Content Objects #2, #4 and #6 to Container #2; a second sample may include assigningContent Objects #1, #3-6 toContainer #1 and Content Object #2 and #7 to Container #2; and a third sample may include assigningContent Objects #1, #4 toContainer #1, Content Object #2 to Container #2, andContent Object #3 and 5 toContainer #3. In some instances, one or more of the number of containers, container-assignment algorithms, number of assigned content objects and identity of assigned content objects does not vary across the samples. For example, the container generator810 may determine a number of containers (e.g., independently from the container-assignment analyzer830 or based on a separate container-assignment analysis) and may transmit the number of containers to the container-assignment analyzer830. The number of containers may then remain fixed across generated samples. As another example, the number and/or identity of content objects to be assigned to containers may remain fixed across samples.
• A transmission-time estimator840 may estimate one or more transmission times for each sample. The estimated transmission time may include, e.g., an estimated transmission time for one or more particular content objects (e.g.,Content Object #1 will be transmitted in 2.5 seconds and Content Object #2 will be transmitted in 3.5 seconds, orContent Objects #1 and #2 will be transmitted in 3.5 seconds), for a group of content objects (e.g., all high priority content objects will be transmitted in 4.5 seconds), for all assigned content objects, etc. The transmission time may comprise a time relative to an initiation of container transmission, a request time, a response time, etc. The transmission times may be estimated, e.g., based on the bandwidth predicted by thebandwidth predictor805, empirical data analysis, size of content objects, etc.
• Asample scorer845 may determine a score for each sample. The score may include, e.g., a single value, multiple values, a vector, a distribution, a range, etc. The score may be numeric. The score may include a value along a finite or infinite continuum. The score may include a rank (e.g., ranking across samples).
• The score may be based at least partly on the estimated transmission time(s). For example, higher scores may be associated with shorter estimated transmission times. The score may depend on a total estimated transmission time (e.g., an estimated time for transmitting all containers or all content objects in containers), an estimated transmission time associated with a group of objects (e.g., an estimated time for transmitting all high-priority content objects), and/or an estimated transmission time associated with one, more or all particular objects. In one instance, a value for a transmission-time variable is determined for each content object of a plurality of content objects (e.g., all content objects to be transmitted), and the score is a weighted or unweighted sum of the values.
• In some instances, one or more use times are estimated by a use-time estimator850. A use time may identify a time at which it is estimated that a user will wish to use a content object (e.g., interact with a Javascript script, view an image, initiate a Flash animation, etc.). The use time may be estimated, e.g., based on an analysis performed by theobject usage analyzer620, objectusage statistics628, data from the as-renderedlocator632, prioritizations determined by theobject prioritizor630, etc. For example, objects associated with a priority of sufficiently low rank may be associated with an estimated use time of “0”, indicating that a user will likely wish to use the content object immediately upon loading a page. As another example, objects located at a top of a page may be associated with use times shorter than objects located at a bottom of a page. As another example, object use times may include a median actual use time. As another example, the object usage statistics may include a distribution of access times, and the use time may include a time at which X % (e.g., 5%) of the population had accessed the object by that point, or the use time may include a fastest access time amongst a population. The use-time estimation may include, e.g., a single time or distribution of times.
• The score determined by thesample scorer845 may at least partly depend on the one or more use times estimated by the use-time estimator. In some instances, the score is at least partly based on comparing the estimated transmission time to the estimated use time. The comparison may result in a binary or non-binary value. For example, for each content object it may be determined whether the estimated transmission time is shorter than the estimated use time, or—in instances in which the estimated transmission time and/or estimated use time comprise probability distributions—the probability that the estimated transmission time is shorter than the estimated use time.
• The container-assignment analyzer830 may include anobject weight assigner855. Theobject weight assigner855 may assign a weight to one or more variables contributing to a score determined by the sample scorer. In some instances, the score comprises a summation of variable values, each value being associated with a different content object or set of content objects. Theobject weight assigner855 may assign a weight to be associated with each content object or set of content objects. The weight may be based, e.g., on a priority determined by theobject priotizor630. Thus, a score may be more heavily influenced by estimated transmission times associated with high-priority content objects as compared to estimated transmission times associated with low-priority content objects.
• Based on the scores determined by the sample scorer, the container generator810 may determine a number of containers to generator and/or the object distributor815 may determine a distribution scheme, a number of content objects to distribute amongst containers and/or an identity of content objects to distribute amongst containers. The determination may be based at least partly on samples associated with high scores. For example, if a highest score sample has a particular content-object distribution technique, the object distributor815 may use a similar distribution technique.
• In some instances, thedelivery controller650 does not include a container-assignment analyzer830 that generates and analyzes samples. For example, thedelivery controller650 may determine a number of containers to be generated and/or object distribution schemes based on solving one or more transmission equations to transmit select or all of the content objects quickly, most quickly or prior to estimated use.
• With reference toFIG. 9, a flow diagram of an embodiment of a process900 for delivering content objects is shown. The depicted portion of the process begins instep905 where a transmission protocol is analyzed. For example, a protocol, such as TCP, may limit throughput of a connection based on various factors. These factors may be identified and analyzed.
• Atblock910, thebandwidth predictor805 predicts the a bandwidth. At block915, a container generator determines a number of containers to associate with a content file or a number of containers generally. The number of containers may be based at least partly on the predicted bandwidth and analysis of the transmission protocol. Atblock920, the container generator generates the containers. Atblock925, theobject distributor830 receives object prioritization e.g., from theobject prioritizor630. Atblock930, an object-distribution scheme is determined by the object distributor915. The object-distribution scheme may or may not vary across different distributions. A distribution scheme may consider, e.g., object priorities, a number of generated containers, object sizes, and/or estimated object use times to determine how objects are to be distributed amongst the containers. Atblock935, content objects (e.g., associated with a content file) are distributed amongst the containers in accordance with the determined object-distribution scheme. Atblock940, the containers are then be delivered, e.g., to anend user system120.
• Thus, each content file of a plurality of content files may be associated with one or more (e.g., a plurality of) containers, and at least some of the content objects associated with the content file may be distributed amongst the containers. In some instances, at least some content objects are not distributed amongst the containers. For example, some (e.g., high priority) content objects may be integrated into the content file itself, and/or some (e.g., rarely used) content objects may be available only upon request.
• With reference toFIG. 10, a flow diagram of an embodiment of aprocess1000 for determining a container property (e.g., a number of containers to generate, an object-distribution scheme, etc.) is shown. The depicted portion of the process begins instep1005 where a containerizing sample is generated by thecontainerizing sample generator835. The sample may include a container assignment for each of a plurality of content objects. Atblock1010, one or more transmission times are estimated by the transmission-time estimator840. For example, an estimate of a time required for each content object of the plurality of content objects to be fully transmitted, relative to an initiation of container transmission, may be made. At block1015, one or more use times are estimated by use-time estimator850. The use-time estimates may depend, e.g., on an empirical-data analysis, as-rendered page location of the objects, etc. At block1020, a weight is determined for one or more content objects or groups of content objects by theobject weight assigner855. For example, a weight may be determined for each content object to be transmitted. The weight may depend, e.g., on a priority associated with the content object. At block1025, a score is assigned to the sample by thesample scorer845. The assigned score may be based on one or more of the estimated transmission time(s), estimated use time(s), and content-object weight(s). For example, in one instance, the assigned score depends on the number of content objects estimated to be fully transmitted prior to a user's attempted use of the object.
• Blocks1005-1025 may be repeated, such that a plurality of samples are generated and scored. Each sample may be associated, e.g., with different distributions of content objects and/or number of containers. At block1030, a container property (e.g., number of containers, distribution schemes, content objects to distribute, etc.) is determined. The determined container property may or may not be specific, e.g., to particular content objects, to a specific content file embedding or referencing the content objects, specific transmission lines, specific requests, etc.
• Referring next toFIG. 11, an exemplary environment with which embodiments may be implemented is shown with acomputer system1100 that can be used by a designer1104 to design, for example, electronic designs. Thecomputer system1100 can include acomputer1102,keyboard1122, a network router1112, aprinter1108, and amonitor1106. Themonitor1106,processor1102 andkeyboard1122 are part of a computer system1126, which can be a laptop computer, desktop computer, handheld computer, mainframe computer, etc. Themonitor1106 can be a CRT, flat screen, etc.
• A designer1104 can input commands into thecomputer1102 using various input devices, such as a mouse,keyboard1122, track ball, touch screen, etc. If thecomputer system1100 comprises a mainframe, a designer1104 can access thecomputer1102 using, for example, a terminal or terminal interface. Additionally, the computer system1126 may be connected to aprinter1108 and aserver1110 using a network router1112, which may connect to theInternet1118 or a WAN.
• Theserver1110 may, for example, be used to store additional software programs and data. In one embodiment, software implementing the systems and methods described herein can be stored on a storage medium in theserver1110. Thus, the software can be run from the storage medium in theserver1110. In another embodiment, software implementing the systems and methods described herein can be stored on a storage medium in thecomputer1102. Thus, the software can be run from the storage medium in the computer system1126. Therefore, in this embodiment, the software can be used whether or notcomputer1102 is connected to network router1112.Printer1108 may be connected directly tocomputer1102, in which case, the computer system1126 can print whether or not it is connected to network router1112.
• With reference toFIG. 12, an embodiment of a special-purpose computer system1200 is shown. For example, one or more of content-modifyingsystem300, object-delivery system600,delivery controller650 may be a special-purpose computer system1200. The above methods may be implemented by computer-program products that direct a computer system to perform the actions of the above-described methods and components. Each such computer-program product may comprise sets of instructions (codes) embodied on a computer-readable medium that directs the processor of a computer system to perform corresponding actions. The instructions may be configured to run in sequential order, or in parallel (such as under different processing threads), or in a combination thereof. After loading the computer-program products on a general purpose computer system1126, it is transformed into the special-purpose computer system1200.
• Special-purpose computer system1200 comprises acomputer1102, amonitor1106 coupled tocomputer1102, one or more additional user output devices1230 (optional) coupled tocomputer1102, one or more user input devices1240 (e.g., keyboard, mouse, track ball, touch screen) coupled tocomputer1102, an optional communications interface1250 coupled tocomputer1102, a computer-program product1205 stored in a tangible computer-readable memory incomputer1102. Computer-program product1205 directssystem1200 to perform the above-described methods.Computer1102 may include one or more processors1260 that communicate with a number of peripheral devices via a bus subsystem1290. These peripheral devices may include user output device(s)1230, user input device(s)1240, communications interface1250, and a storage subsystem, such as random access memory (RAM)1270 and non-volatile storage drive1280 (e.g., disk drive, optical drive, solid state drive), which are forms of tangible computer-readable memory.
• Computer-program product1205 may be stored innon-volatile storage drive1280 or another computer-readable medium accessible tocomputer1102 and loaded intomemory1270. Each processor1260 may comprise a microprocessor, such as a microprocessor from Intel® or Advanced Micro Devices, Inc.®, or the like. To support computer-program product1205, thecomputer1102 runs an operating system that handles the communications ofproduct1205 with the above-noted components, as well as the communications between the above-noted components in support of the computer-program product1205. Exemplary operating systems include Windows® or the like from Microsoft Corporation, Solaris® from Sun Microsystems, LINUX, UNIX, and the like.
• User input devices1240 include all possible types of devices and mechanisms to input information tocomputer system1102. These may include a keyboard, a keypad, a mouse, a scanner, a digital drawing pad, a touch screen incorporated into the display, audio input devices such as voice recognition systems, microphones, and other types of input devices. In various embodiments, user input devices1240 are typically embodied as a computer mouse, a trackball, a track pad, a joystick, wireless remote, a drawing tablet, a voice command system. User input devices1240 typically allow a user to select objects, icons, text and the like that appear on themonitor1106 via a command such as a click of a button or the like. User output devices1230 include all possible types of devices and mechanisms to output information fromcomputer1102. These may include a display (e.g., monitor1106), printers, non-visual displays such as audio output devices, etc.
• Communications interface1250 provides an interface to other communication networks and devices and may serve as an interface to receive data from and transmit data to other systems, WANs and/or theInternet1118. Embodiments of communications interface1250 typically include an Ethernet card, a modem (telephone, satellite, cable, ISDN), a (asynchronous) digital subscriber line (DSL) unit, a FireWire® interface, a USB® interface, a wireless network adapter, and the like. For example, communications interface1250 may be coupled to a computer network, to a FireWire® bus, or the like. In other embodiments, communications interface1250 may be physically integrated on the motherboard ofcomputer1102, and/or may be a software program, or the like.
• RAM1270 andnon-volatile storage drive1280 are examples of tangible computer-readable media configured to store data such as computer-program product embodiments of the present invention, including executable computer code, human-readable code, or the like. Other types of tangible computer-readable media include floppy disks, removable hard disks, optical storage media such as CD-ROMs, DVDs, bar codes, semiconductor memories such as flash memories, read-only-memories (ROMs), battery-backed volatile memories, networked storage devices, and the like.RAM1270 andnon-volatile storage drive1280 may be configured to store the basic programming and data constructs that provide the functionality of various embodiments of the present invention, as described above.
• Software instruction sets that provide the functionality of the present invention may be stored inRAM1270 andnon-volatile storage drive1280. These instruction sets or code may be executed by the processor(s)1260.RAM1270 andnon-volatile storage drive1280 may also provide a repository to store data and data structures used in accordance with the present invention.RAM1270 andnon-volatile storage drive1280 may include a number of memories including a main random access memory (RAM) to store of instructions and data during program execution and a read-only memory (ROM) in which fixed instructions are stored.RAM1270 andnon-volatile storage drive1280 may include a file storage subsystem providing persistent (non-volatile) storage of program and/or data files.RAM1270 andnon-volatile storage drive1280 may also include removable storage systems, such as removable flash memory.
• Bus subsystem1290 provides a mechanism to allow the various components and subsystems ofcomputer1102 communicate with each other as intended. Although bus subsystem1290 is shown schematically as a single bus, alternative embodiments of the bus subsystem may utilize multiple busses or communication paths within thecomputer1102.
• Specific details are given in the above description to provide a thorough understanding of the embodiments. However, it is understood that the embodiments may be practiced without these specific details. For example, circuits may be shown in block diagrams in order not to obscure the embodiments in unnecessary detail. In other instances, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail in order to avoid obscuring the embodiments.
• Implementation of the techniques, blocks, steps and means described above may be done in various ways. For example, these techniques, blocks, steps and means may be implemented in hardware, software, or a combination thereof. For a hardware implementation, the processing units may be implemented within one or more application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), processors, controllers, micro-controllers, microprocessors, other electronic units designed to perform the functions described above, and/or a combination thereof.
• Also, it is noted that the embodiments may be described as a process which is depicted as a flowchart, a flow diagram, a data flow diagram, a structure diagram, or a block diagram. Although a flowchart may describe the operations as a sequential process, many of the operations can be performed in parallel or concurrently. In addition, the order of the operations may be re-arranged. A process is terminated when its operations are completed, but could have additional steps not included in the figure. A process may correspond to a method, a function, a procedure, a subroutine, a subprogram, etc. When a process corresponds to a function, its termination corresponds to a return of the function to the calling function or the main function.
• Furthermore, embodiments may be implemented by hardware, software, scripting languages, firmware, middleware, microcode, hardware description languages, and/or any combination thereof. When implemented in software, firmware, middleware, scripting language, and/or microcode, the program code or code segments to perform the necessary tasks may be stored in a machine readable medium such as a storage medium. A code segment or machine-executable instruction may represent a procedure, a function, a subprogram, a program, a routine, a subroutine, a module, a software package, a script, a class, or any combination of instructions, data structures, and/or program statements. A code segment may be coupled to another code segment or a hardware circuit by passing and/or receiving information, data, arguments, parameters, and/or memory contents. Information, arguments, parameters, data, etc. may be passed, forwarded, or transmitted via any suitable means including memory sharing, message passing, token passing, network transmission, etc.
• For a firmware and/or software implementation, the methodologies may be implemented with modules (e.g., procedures, functions, and so on) that perform the functions described herein. Any machine-readable medium tangibly embodying instructions may be used in implementing the methodologies described herein. For example, software codes may be stored in a memory. Memory may be implemented within the processor or external to the processor. As used herein the term “memory” refers to any type of long term, short term, volatile, nonvolatile, or other storage medium and is not to be limited to any particular type of memory or number of memories, or type of media upon which memory is stored.
• Moreover, as disclosed herein, the term “storage medium” may represent one or more memories for storing data, including read only memory (ROM), random access memory (RAM), magnetic RAM, core memory, magnetic disk storage mediums, optical storage mediums, flash memory devices and/or other machine readable mediums for storing information. The term “machine-readable medium” includes, but is not limited to portable or fixed storage devices, optical storage devices, wireless channels, and/or various other storage mediums capable of storing that contain or carry instruction(s) and/or data.
• While the principles of the disclosure have been described above in connection with specific apparatuses and methods, it is to be clearly understood that this description is made only by way of example and not as limitation on the scope of the disclosure.

Claims (20)

1. A system for dynamically serving a content file with embedded or referenced content objects over the Internet to an end user system, the system comprising:

a content object request function that receives a request, from the end user system, for a webpage defined by the content file, the content file comprising a plurality of embedded or referenced content objects, wherein at least one of the plurality of content objects comprises an image;

a content-file modifier that modifies the content file, the content-file modifier comprising:

a reporting-code injector that injects a reporting code into the content file, the reporting code comprising instructions to generate one or more reports comprising information relating to invocation of stubs;

a content-file parser that identifies each content object of the plurality of content objects embedded or referenced in the content file; and

a stub controller that replaces each of at least two of the identified content objects with a stub, wherein the stub requests the identified content object from a remote source upon invocation of the stub;

a report receiver that receives reports generated in response to implementation of the reporting code in the modified content file;

an object usage analyzer that dynamically analyzes the received reports to quantify usage of each of the stubs;

an object prioritizor that prioritizes, in real time, at least two content objects of the plurality of content objects based at least partly on the dynamic analysis of the received reports, wherein the prioritization comprises an identification of at least one high-priority content object, and

an object injector that, in real-time, modifies the content file such that the high-priority content object automatically loads upon rendering of the content file.

2. The system for dynamically serving the content file with content objects over the Internet to the end user system as recited inclaim 1, wherein the object prioritizor is located at an edge server of a content distribution network (CDN), the CDN comprising:

a plurality of points of presence (POPs), wherein:

the plurality of POPs are geographically distributed;

the plurality of POPs include a POP, and

each of the plurality of POPs comprises a plurality of servers including the edge server.

3. The system for dynamically serving the content file with embedded or referenced content objects over the Internet to the end user system as recited inclaim 1, wherein the object-usage analyzer comprises:

an access detector that detects, based at least partly on the received reports, invocations of each of the stubs; and

a usage-time-stamp identifier that identifies, based at least partly on the received reports, temporal features relating to the invocations of each of the stubs,

4. The system for dynamically serving the content file with embedded or referenced content objects over the Internet to the end user system as recited inclaim 1, where the at least one high-priority content object is identified by comparing invocations of a stub associated with the high-priority content object to invocations of one or more other stubs in the modified content file.

5. The system for dynamically serving the content file with embedded or referenced content objects over the Internet to the end user system as recited inclaim 1, further comprising a content-file database,

wherein the content-file modifier stores the modified content file in the content-file database.

6. The system for dynamically serving the content file with embedded or referenced content objects over the Internet to the end user system as recited inclaim 1, wherein each stub in the modified content file:

determines whether a content object associated with the stub has been loaded, and

upon determining that the associated content object has not been loaded, requests the associated content object from the remote source.

7. A system for dynamically serving content files with embedded or referenced content objects over the Internet to an end user system, the system comprising:

a content object request function that receives a request, from the end user system, for one or more content files, the one or more content files embedding or referencing a plurality of content objects, wherein at least one of the plurality of content objects comprises an image;

a reporting-code injector that injects a reporting code into the content file, the reporting code comprising instructions to generate one or more reports comprising information relating to the invocation of subs;

a content-file transmitter that transmits a modified version of the one or more content file in response to the request, from the end user system, for the one or more content files, wherein the modified version of the one or more content files comprises a plurality of stubs, each stub being associated with a content object of the plurality of content objects, wherein each stub requests the associated content object from a remote source upon invocation of the stub;

a report receiver that receives reports generated in response to implementations of the reporting code in the modified content file;

an object usage analyzer that dynamically generates statistics identifying frequencies of invocations of the stubs;

an object prioritizor that assigns priorities to the content objects associated with the plurality of stubs in real time, the assigned priorities being based at least partly on the statistics dynamically generated by the object usage analyzer that identifies the frequencies of invocations of the stubs; and

an object injector that, in real time, modifies the content file such that the high-priority content object automatically loads upon rendering of the content file.

8. The system for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 7, the system further comprising:

an object access improver that coordinates automatic loading of the content objects assigned a high priority at another end user system that requested the one or more content files subsequent to the object prioritization.

9. The system for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 7, the system further comprising:

a stub controller that replaces stubs associated with content objects assigned a high priority with the associated content object.

10. The system for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 7, the system further comprising a content-file modifier that generates the modified version of the one or more content files, the content-file modifier comprising:

a content-file parser that identifies each the first content object and the second content object embedded or referenced in the one or more content files; and

a stub injector that injects the first stub to replace the first content object and the second stub to replace the second content object in the one or more content files.

11. The system for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 7, the system further comprising a content-file modifier that generates the modified version of the one or more content files, the content-file modifier comprising:

a reporting-code injector that injects a reporting code into the one or more content files, the reporting code comprising instructions to generate one or more reports comprising information relating to invocation of the first stub and the second stub.

12. The system for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 7, wherein the frequency of invocation of the first stub comprises a binary indication as to whether the stub had been invoked at least once.

13. The system for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 7, wherein the object prioritizor assigns the high priority to the at least one of the first content object and the second content object based on a comparison between each of the frequency of invocation of the first stub and the frequency of invocation of the second stub to an absolute threshold.

14. A method for dynamically serving content files with embedded or referenced content objects over the Internet to an end user system, the method comprising:

receiving a request, from the end user system, for one or more content files, the one or more content files embedding or referencing a plurality of content objects, wherein at least one of the plurality of content objects comprises an image;

injecting a reporting code into the content file, the reporting code comprising instructions to generate one or more reports comprising information relating to the invocation of subs;

transmitting a modified version of the one or more content file in response to the request, from the end user system, for the one or more content files, wherein the modified version of the one or more content files comprises a plurality of stubs, each stub being associated with a content object of the plurality of content objects, wherein each stub requests the associated content object from a remote source upon invocation of the stub;

receiving reports generated in response to implementations of the reporting code in the modified content file;

dynamically generating statistics identifying frequencies of invocations of the stubs;

assigning priorities to the content objects associated with the plurality of stubs in real time, the assigned priorities being based at least partly on the statistics dynamically generated by the object usage analyzer that identifies the frequencies of invocations of the stubs; and

modifying the content file such that the high-priority content object automatically loads upon rendering of the content file.

15. The method for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 14, the method further comprising:

coordinating automatic loading of the content objects assigned a high priority at another end user system that requested the one or more content files subsequent to the object prioritization.

16. The method for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 15, wherein the coordinating the automatic loading of the content objects assigned a high priority at another end user system that requested the webpage subsequent to the object prioritization comprises revising the one or more content files.

17. The method for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 14, wherein the request comprises a uniform resource locator, and the one or more content files define a webpage.

18. The method for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 14, further comprising:

receiving reporting data from the end user system identifying which of the stubs were accessed,

wherein the dynamically generating statistics are based at least partly on the reporting data.

19. The method for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 14, wherein a first stub of the plurality of stubs requests a content object associated with the first stub from a first remote source and a second stub of the plurality of stubs requests a content object associated with the second stub from a second remote source, the first remote source and second remote source being different.

20. The method for dynamically serving content files with embedded or referenced content objects over the Internet to the end user system as recited inclaim 14, wherein the plurality of content objects comprise at least one embedded content object and at least one referenced content object.

Images