Abstract:
A reservation system for making reservations in a shared memory buffer to store information from applications is logically partitioned in a number of fixed size indexed contiguous slots. The reservation system uses an atomic counter that is stored in the shared memory buffer. The value of the atomic counter can be associated with the index of a slot available for reservation. An application making a reservation increases the atomic counter value on a number of reserved slots to provide a value that is associated with the index of the next slot available for reservation. After the reservation is accomplished, the information is written into the reserved slots. The reservation system writes parsing information for further parsing to validate information in the shared memory buffer. The reservation system provides functionality for continuous and instantaneous dumping of the shared memory buffer into a file for cleaning and for wrapping the buffer.

Description:
FIELD OF THE INVENTION  
         [0001]    The present invention generally relates to the field of memory management, and it more particularly relates to a system and associated method for shared memory reservation.  
         BACKGROUND OF THE INVENTION  
         [0002]    Commonly, software systems require the storage or transmission of discrete units of data in a chronologically ordered fashion. For efficiency purposes, it is preferable to store or transmit data in large blocks. This eliminates the need for many small disk accesses or transmissions of small network packets, which generally have an adverse effect on system performance. It is also common for a software system that chronologically stores units of data in memory to allow direct memory access to collected, discrete units of data.  
           [0003]    Software systems having multiple processes and/or multithreaded processes usually use a single shared memory buffer for these discrete units of data. At various times, a process or thread (referred to as a “writer” herein) may reserve a region of memory in the buffer to record its data. From time to time, the data collection operation may be reset and the data currently stored in the buffer should be cleared.  
           [0004]    Since the buffer resides in a shared region of memory, the software system should employ a reservation system that ensures concurrent operations do not produce unexpected results. The reservation system should synchronize reservation requests from writers to prevent overlapping. Synchronization is also employed when writing out the data stored using the reservations to a disk or other non-volatile medium or transmitting such data across a network and when clearing the data from reserved memory.  
           [0005]    One application of the reservation system for storing data to a shared memory buffer is a diagnostic facility. Mission critical software products employ diagnostic facilities to collect discrete information about the state of the application allowing the application to be serviced from the field. The efficiency of collecting diagnostic information is crucial specifically in a large, complex system having numerous applications, each having one or more writers executing concurrently. The diagnostic facility is usually shared across the entire system so it can provide an overall impression of the system&#39;s state. Ideally, the diagnostic facility should have zero impact on the system&#39;s performance and functionality. The facility simply needs to quickly record discrete amounts of diagnostic data in the facility&#39;s shared memory buffer. Unfortunately, the synchronization of the shared memory introduces performance penalties. In a worst case scenario, the entire system becomes serialized because of lack of performance crucial to the synchronization mechanism. This could lead to a situation where a problem in the system could not be properly diagnosed because of the negative performance impact of the diagnostic facility.  
           [0006]    A diagnostic facility reservation system typically comprises collection and parsing stages. The collection stage occurs when writers make reservations of a portion of the shared memory and store data in those reserved portions. In this stage, the data in the shared memory buffer may be written to disk or may be cleared if the buffer is reset. Performance is critical in this stage because the reservation system should attempt to minimize its impact on the application.  
           [0007]    The parsing stage involves examining the collected data obtained during the collection stage; the collected data is typically stored in a data file. Performance is relatively unimportant in this stage. Examining the data file is often independent of the application&#39;s core function. It may even be performed on a different computer. Reservation systems that simplify the parsing stage typically penalize the performance of the collection stage.  
           [0008]    Existing reservation system implementations employ overly complicated synchronization mechanisms, using semaphores, mutexes, etc.  
           [0009]    Other software reservation systems usually synchronize for the entire duration of the operation. For example, the reservation logic is usually implemented using the following steps: 1) Wait until the shared memory buffer is unlocked; 2) Lock the shared memory buffer (synchronize); 3) Make the reservation; 4) Return the reservation region to the writer; 5) Wait until writer is finished using the reserved region; and 6) Unlock the shared memory buffer. Clearing or storing the buffer to disk follows a similar logic, comprising steps of: 1) Waiting until the shared memory buffer is unlocked; 2) Locking the shared memory buffer (synchronize); 3) Clearing the shared memory buffer (or writing to disk); and 4) Unlocking the shared memory buffer.  
           [0010]    This lengthy lock-out approach causes writers to queue up, waiting for their chance to acquire the shared memory lock. The operations that occur “under the lock” take a relatively long time, especially the file input/output (I/O) involved in storing the buffer on disk. This may cause the reservation system to serialize the entire software system.  
           [0011]    Therefore, there is a need for a reservation system to provide efficient memory reservation in a shared memory buffer. Furthermore, the needed reservation system should minimally impact the entire software system while memory reservation is being undertaken. The need for such a system has heretofore remained unsatisfied.  
         SUMMARY OF THE INVENTION  
         [0012]    The present invention satisfies this need, and presents a system, a computer program product, and an associated method (collectively referred to herein as “the system” or “the present system”) for providing a data processing system for reserving portions of a shared memory buffer among a plurality of writers sharing the buffer, the data processing system comprising an interface for receiving and responding to individual requests from the plurality of the writers. Each of the requests from an individual writer reserves a contiguous portion of the buffer for writing by the writer. A synchronization mechanism atomically reserves a portion of the shared memory buffer in response to each request.  
           [0013]    In accordance with another aspect of the invention, there is provided, for a data processing system, a method for reserving portions of a shared memory buffer among a plurality of writers sharing the buffer, the method comprising steps of receiving a reservation request from an individual writer to reserve a contiguous portion of the buffer and atomically reserving the contiguous portion of the buffer.  
           [0014]    In accordance with another aspect of the invention, there is provided a computer program product having a computer readable medium tangibly embodying computer readable data processing for directing a data processing system to reserve portions of a shared memory buffer among a plurality of writers sharing the buffer. The computer program product comprises code for receiving a reservation request from an individual writer to reserve a contiguous portion of the buffer and code for atomically reserving the contiguous portion of the buffer.  
           [0015]    In accordance with another aspect of the invention, there is provided a diagnostic facility for a data processing system. The diagnostic facility comprises a reservation mechanism for atomically reserving individual contiguous portions of a shared memory buffer of the data processing system to individual writers of a plurality of writers sharing the memory buffer. Each individual contiguous portion is reserved for writing diagnostic information by an individual writer.  
           [0016]    In accordance with another aspect of the invention, there is provided a computer program product having a computer readable medium tangibly embodying computer readable code for directing a data processing system to implement a diagnostic facility. The computer program product comprises code for implementing a reservation mechanism for atomically reserving individual contiguous portions of a shared memory buffer of the data processing system to individual writers of a plurality of writers sharing the memory buffer. Each individual contiguous portion is reserved for writing diagnostic information by an individual writer.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0017]    The various features of the present invention and the manner of attaining them will be described in greater detail with reference to the following description, claims, and drawings, wherein reference numerals are reused, where appropriate, to indicate a correspondence between the referenced items, and wherein:  
         [0018]    [0018]FIG. 1 is a schematic illustration of an exemplary operating environment in which a reduced synchronization reservation system of the present invention can be used;  
         [0019]    [0019]FIG. 2 is a block diagram of the high-level architecture of a portion of the computer system of FIG. 1;  
         [0020]    [0020]FIG. 3 is a block diagram of the high-level architecture of a portion of the memory of the computer system of FIG. 1, shown in FIG. 2;  
         [0021]    [0021]FIG. 4A is a schematic block diagram illustrating a structure of a buffer illustrated in FIG. 3;  
         [0022]    [0022]FIG. 4B is a schematic block diagram illustrating, in greater detail, a structure of a buffer illustrated in FIG. 4A;  
         [0023]    [0023]FIG. 5 is schematic block diagram illustrating a structure of a dump file for instantaneously dumping;  
         [0024]    [0024]FIG. 6 is a schematic block diagram with flow charts illustrating exemplary methods and their operational steps of the reservation system; and  
         [0025]    [0025]FIG. 7 is comprised of FIGS. 7A and 7B, and represents and illustration of a reservation example of slots using a repeated reservation.  
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0026]    The following detailed description of the embodiments of the present invention does not limit the implementation of the invention to any particular computer programming language. The present invention may be implemented in any computer programming language provided that the OS (Operating System) provides the facilities that may support the requirements of the present invention. An embodiment is implemented in the C or C++ computer programming language (or other computer programming languages in conjunction with C/C++). Any limitations presented would be a result of a particular type of operating system or computer programming language and would not be a limitation of the present invention.  
         [0027]    An embodiment of the invention, computer system  100 , is illustrated in FIG. 1. Computer system  100 , which is illustrated for exemplary purposes as a computing device, is adapted to communicate with other computing devices (not shown) using network  102 . As may be appreciated by those of ordinary skill in the art, network  102  may be embodied using conventional networking technologies and may comprise one or more of the following: local networks, wide area networks, intranets, the Internet, and the like.  
         [0028]    Through the description herein, an embodiment of the invention is illustrated with aspects of the invention embodied solely on computer system  100 . As may be appreciated by those of ordinary skill in the art, aspects of the invention may be distributed amongst one or more networked computing devices which interact with computer system  100  using one or more networks such as, for example, network  102 . However, for ease of understanding, aspects of the invention have been embodied in a single computing device—computer system  100 .  
         [0029]    Computer system  100  typically comprises a processing system  104  that is enabled to communicate with the network  102 , and various input devices  106  and output devices  108 . Input devices  106 , (a keyboard and a mouse are shown) may also comprise a scanner, an imaging system (e.g., a camera, etc.), or the like. Similarly, output devices  108  (only a display is illustrated) may also comprise printers and the like. Input device  106  and output device  108  may alternately be referenced as I/O devices  106  and  108 . Additionally, combination input/output (I/O) devices  106  and  108  may also be in communication with processing system  104 . Examples of conventional I/O devices (not shown in FIG. 1) comprise removable recordable media (e.g., floppy disk drives, tape drives, CD-ROM drives, DVD-RW drives, etc.), touch screen displays, and the like.  
         [0030]    Exemplary processing system  104  is illustrated in greater detail in FIG. 2. As illustrated, processing system  104  comprises a number of components: a central processing unit (CPU)  202 , memory  204 , network interface (I/F)  206  and input-output interface (I/O I/F)  208 . Communication between various components of the processing system  104  may be facilitated via a suitable communications bus  210  as required.  
         [0031]    CPU  202  is a processing unit, such as an Intel Pentium™, IBM PowerPC™, Sun Microsystems UltraSparc™ processor, or the like, suitable for the operations described herein. As may be appreciated by those of ordinary skill in the art, other embodiments of processing system  104  could use alternative CPUs  202  and may comprise embodiments in which one or more CPUs  202  are employed (not shown). CPU  202  may comprise various support circuits to enable communication between itself and the other components of processing system  104 .  
         [0032]    Memory  204  comprises both volatile memory  212  and persistent memory  214  for the storage of: operational instructions for execution by CPU  202 , data registers, application and thread storage, and the like. Memory  204  comprises a combination of random access memory (RAM), read only memory (ROM) and persistent memory such as that provided by a hard disk drive.  
         [0033]    Network I/F  206  enables communication between other computing devices (not shown) and other network computing devices via network  102 . Network I/F  206  may be embodied in one or more conventional communication devices. Examples of a conventional communication device comprise: an Ethernet card, a token ring card, a modem, or the like. Network I/F  206  may also enable the retrieval or transmission of instructions for execution by CPU  202 , from or to a remote storage media or device via network  102 .  
         [0034]    I/O I/F  208  enables communication between processing system  104  and the various I/O devices  106  and  108 . I/O I/F  208  may comprise, for example, a video card for interfacing with an external display such as output device  108 . Additionally, I/O I/F  208  may enable communication between processing system  104  and a removable media  216 . Removable media  216  may comprise a conventional diskette or other removable memory devices such as Zip™ drives, flash cards, CD-ROMs, static memory devices and, the like. Removable media  216  may be used to provide instructions for execution by CPU  202  or as a removable data storage device.  
         [0035]    The computer instructions/applications stored in memory  204  and executed by CPU  202  (thus adapting the operation of computer system  100  as described herein) are illustrated in functional block form in FIG. 3. As may be appreciated by those of ordinary skill in the art, the discrimination between aspects of the applications illustrated as functional blocks in FIG. 3 is somewhat arbitrary in that the various operations attributed to a particular application as described herein may, in an_alternative embodiment, be subsumed by another application.  
         [0036]    As illustrated for exemplary purposes only, memory  204  stores a number of applications and data for enabling the operation of the system for reserving memory  204  that comprise: an operating system (OS)  302 , a communication suite  304 , and a memory reservation system  306 . The memory reservation system  306  (alternately referenced as reservation system  306 ) comprises a reservation interface  308  (alternately referenced as interface  308 ) such as an application program interface (API). The system for reserving memory  204  also comprises at least one application  310  comprising multiple processes P 1 , P 2 , P 3 , P 4  ( 312   a ,  312   b ,  312   c ,  312   d ) of which P 4   312   d  comprises a multithreaded process having exemplary threads T 1 , T 2  and T 3  ( 314   a ,  314   b ,  314   c ) and a buffer  316 . Collectively, said processes  312   a - 312   d  and threads  314   a - 314   c  are referred to as writers  317 .  
         [0037]    OS  302  is an operating system suitable for operation with a selected CPU  202  and the operations described herein. Multi-tasking, multi-threaded OSs such as, for example, IBM AIX™, Microsoft Windows, Linux or the like, are expected to be preferred in many embodiments. Buffer  316  is specifically reserved as a contiguous region of the memory  204  for storing information. Communication suite  304  provides, through interaction with OS  302  and network I/F  206  (FIG. 2), suitable communication protocols to enable communication with other networked computing devices via network  102  (FIG. 1). Communication suite  304  may comprise one or more of such protocols such as TCP/IP, Ethernet, token ring and the like. Communications suite  304  comprises asynchronous transport communication capabilities for communicating with other computing devices.  
         [0038]    The reservation system  306  uses a synchronization mechanism that operates atomically to ensure each reservation request receives a unique reserved portion of the shared memory buffer  316  to improve the performance of the collection stage. An atomic counter in the present embodiment provides a synchronization mechanism that ensures that only one process  312   a - 312   d  or writer  317  can modify the counter&#39;s value at a time. The shared memory buffer  316  is divided into numerous fixed size regions called “slots”. Reservations are always made in multiples of slots. An atomic sequence counter is used to indicate the next available slot. A writer  317  makes a reservation by incrementing the atomic sequence counter by the number of slots requested. The previous value of the counter is then used to identify the start of the reserved region of memory  204  of the writer  317 . It may be understood by persons of ordinary skill in the art that a count down approach may be used with the previous counter value indicating the end of the reserved region of the writer  317 .  
         [0039]    The reservation system  306  is implemented through an interface  308  that provides functionality to: calculate the memory requirements for a buffer  316 ; initialize a buffer  316 ; reserve a region of memory  204  within a buffer  316 ; synchronize changes to the reserved region of memory  204 ; invalidate all the current contents of the buffer  316 ; dump the contents of the entire buffer  316 ; and parse a buffer dump file.  
         [0040]    The reservation system  306 , incorporating aspects of the present invention in the exemplary embodiment using the reservation interface  308 , provides a memory reservation system  306  for writing information from at least one of the writers  317  into the buffer  316 . In the illustrated example, each writer  317  is stored in the memory  204 , but it is to be understood that a writer  317  may be executed on another remotely located computing device (not shown) that is enabled to communicate with the interface  308  via communication suite  304 . Such an approach is not preferred for many applications as the transmission delays may likely impact the performance of the remotely located computing device. It may be understood by persons of ordinary skill in the art that each writer  317  is adapted to support communication with the reservation interface  308 , for example, using an API (not shown).  
         [0041]    [0041]FIG. 4A is a schematic block diagram illustrating a structure of a region  402  of volatile memory  212  reserved for buffer  316 . The region  402  of the volatile memory  212  is reserved for a shared memory buffer  316  to provide storage facilities for information from the writers  317 . The region  402  comprises a control region  404 , a data storing region  406  and a wasteland region  408 . The data storing region  406  comprises a number of equal fixed-size portions or chunks  410 . Each chunk  410  comprises a plurality of smaller fixed-size portions or slots  412 . In the buffer  316  illustrated in FIG. 4B, each slot  412  comprises a header region  414 , a body region (body)  416  and a tail region  418 . The header region  414  comprises a sequence region  420 , a signature region  422  and a number of slots  424 .  
         [0042]    The reservation system  306  operates using a staged approach. During the collection stage, writers  317  make respective requests to reserve parts of buffer  316  and write respective data in these reserved portions. During the collection stage, one or more data files are created from data stored to buffer  316 . During the parsing stage, these one or more data files are examined. In order to perform the reservation, the reservation system  306  uses a number of variables. One of these is an atomic counter variable for indicating the next available slot  412  for reservation among other things as described further below. Employing an atomic counter variable improves performance of the collection stage providing an efficient synchronization mechanism to ensure that only one writer  317  can make a reservation at any one time without any interference from other writers  317 . The atomic counter variable is stored in the control region  404  FIG. 4A.  
         [0043]    An individual writer  317  requests a reservation through interface  308  to invoke the synchronization mechanism. The synchronization mechanism increments the atomic counter value by the number of slots  424  requested by the writer  317 . The previous value of the atomic counter variable, named a sequence variable, is stored in the sequence region  420  and is used to identify the index of the first slot  412  of the reservation. The interface  308  provides the writer  317  with the reservation (i.e. slot number). Once the reservation is obtained, writer  317  is free to modify the reserved memory region and write the information to be stored in the body  416  of the slot  412  as and when desired.  
         [0044]    On completion of the modification, writer  317  notifies the reservation system  306  through interface  308 . The reservation system  306  then modifies the reserved memory region with a finalization function to indicate that the reserved memory region is complete. In the present embodiment, the reservation system  306  records the sequence number of the reservation into the sequence region  420  of the reserved slot  412 . A synchronization value is then written in the tail region  418 . This synchronization value is based on the reservation sequence number and is used to indicate that the modifications of the writer  317  are complete. The synchronization value reduces the possibility of incorrectly identifying some regions of the memory  204  as valid reservations. The reservation system  306  also records a special well-known identification value in the signature region  422 .  
         [0045]    Information in the signature region  422  and tail region  418  is used during the parsing stage to identify valid reservations as discussed further herein below. In the reservation system  306 , synchronization for assigning a portion of shared memory buffer  316  only occurs when the atomic counter is modified and no additional synchronization is required. The reservation system  306  does not lock the buffer  316  to prevent future reservations while a writer  317  completes its modifications. This approach reduces the overall synchronization duration and allows writers  317  to concurrently modify their reserved regions. The reservation system  306  can dump (i.e. write out) contents of the buffer  316  into the persistent memory  214  such as a hard disk, as a file. Since the reservation system  306  cannot “lock out” reservations, writers  317  may be making reservations and modifying their reservations while the buffer  316  is written to the data file. This may cause the presence of incomplete data in the dump file. Once the buffer  316  has been written, the reservation system  306  records the current value of the atomic counter variable in the sequence region  420  of the reserved slot  412 . A sequence value in the sequence region  420  indicates a sequence number that may be assigned for the next reservation. The sequence value is also used to determine the location of the oldest potentially valid reservation in the dump file for validation purposes during the parsing stage. A sequence number of a valid reservation has to be within a specified range that can be calculated using the following equation:  
         (nextSequence−max Slot)≦Sequence&lt;nextSequence  (1)  
         [0046]    wherein: nextSequence is a value stored in the sequence region  420  of the next slot  412 ; maxSlot is the total number of slots  412  in buffer  316 ; and Sequence is a variable stored in the sequence region  420  of the slot  412  being evaluated indicating the sequence number for the current reservation to which the slot  412  was assigned.  
         [0047]    If the equation is satisfied, Sequence is considered valid, and a signature value stored in the signature region  422  and a tail value stored in the tail region  418  can be validated. If the values indicate that the writing was not completed, the information in the slot  412  is ignored as invalid.  
         [0048]    The reservation system  306  is enabled to clear or reset the buffer  316  in order to remove the existing reservations. By incrementing the atomic counter value by a multiple of a total number of slots  412  in the buffer  316  (maxSlots), current reservations are reset. The next reservation may still occur in the same slot index due to modulo arithmetic but during the parsing stage, all the previous reservations having sequence numbers that are out of the valid range failing to satisfy equation 1 may be ignored. As a result, the reservation system  306  can quickly and effectively remove previous reservations without the necessity to lock out new reservations or modify existing reservations. Resetting the buffer  316  is not applicable when continuous dumps are used.  
         [0049]    The reservation system  306  is enabled to operate in wrap, non-wrap and dump modes. In the wrap mode, buffer  316  operates as a circular buffer  316  with the stored information in the buffer  316  being cyclically overwritten. In the dump mode, information from the buffer  316  can also be dumped as a file into the persistent memory  214 . Dumping can be performed either occasionally (for example, periodically or on-demand) or continuously.  
         [0050]    In the wrap mode, the buffer  316  preserves only the most recent reservations which is often desirable in a diagnostic facility. Buffer wrapping occurs in an incremental implementation when the value of the atomic sequence exceeds the total number (maxSlot) of slots  412  in the buffer  316 .  
         [0051]    [0051]FIG. 5 is a schematic block diagram illustrating a structure of a dump file  500  for occasional dumping. The dump file  500  comprises buffer contents  502  that is preceded by a header region  504  and ended by a dump file tail region  506 . In the case of continuous dumping, the reservation system  306  does not use the dump file tail region  506  and respectively uses only the dump file header region  504 .  
         [0052]    The header region  504  of the buffer  316  comprises a buffer size region  508 , a dump type region  510 , and a wrap region  512 .  
         [0053]    The buffer size region  508  is used for storing information about the total number of bytes in the buffer  316 . The number of slots  412  in the buffer  316  can be calculated using a value stored in the buffer size region  508 . The dump type region  510  is used for storing a variable that indicates an active type of dumping that can be either occasional or continuous. The wrap region  512  is used for storing a variable that indicates a status of buffer wrapping (e.g. active or not). In the present embodiment of the invention, a nonzero value stored in the wrap region  512  indicates that the buffer wrapping is enabled. Otherwise the value is zero.  
         [0054]    The dump file tail region  506  comprises a next sequence region  516 , a first slot index region  518 , an initial sequence region  520  and a truncated region  522 . The next sequence region  516  is used for storing a low 32-bit sequence value of the next reservation that is taken from the current value of the next sequence variable in the control block, control region  404  FIG. 4A. The first slot index region  518  is used for storing the slot index variable of the first slot  412  to parse. If buffer wrapping is disabled, this value is equal to zero. The initial sequence region  520  is used to determine if the buffer  316  has wrapped and is applicable if buffer wrapping was enabled. The truncated region  522  is used as a flag that indicates whether or not the buffer  316  was truncated. This is only applicable if buffer wrapping was disabled.  
         [0055]    For I/O efficiency, in the present embodiment of the invention the size of the chunk  410  is 128 kilobytes and the size of the slot  412  is 64 bytes. Thus, each chunk  410  comprises 2048 slots  412 .  
         [0056]    [0056]FIG. 6 is a block diagram with flow charts illustrating exemplary methods and the main operational steps involved in reserving portions of the buffer  316  as well as dumping and resetting the buffer  316 . FIG. 6 shows methods for initialization  601 , reservation  603 , occasional dumping  605 , resetting  607 , completion  609 , and continuous dumping  611 . In an initialization step (Step  604 ), the reservation system  306  reserves a contiguous region of memory, region  402 , for the buffer  316  using OS  302 . The system  306  allocates the required amount of volatile memory  212  to accommodate a specified predetermined size of buffer  316  and provides a starting address of the buffer  316  in the volatile memory  212 . As is described in FIG. 4, the buffer  316  starts from the control region  404  which is used for storing an atomic counter variable. Next, the reservation system  306  initiates the buffer  316  (Step  606 ) making it ready for further writing information from writers  317 . As is described above, each writer  317  may request a reservation of a portion of the buffer  316  using interface  308 .  
         [0057]    The reservation system  306  receives a request (Step  608 ) to reserve one or more slots  412  to provide an adequate size of the memory  204  for the data. Reservations may be made on slot boundaries allocating one or more complete slots  412 . A reservation cannot exceed the total number of slots  412  in the buffer  316 . Also, in the present embodiment of the invention, individual reservations cannot be larger than a single chunk  410 . In the present embodiment of the invention having a slot size of 64 bytes, the header region  414  is equal to 8 bytes comprising the sequence region having 4 bytes, the signature region  422  having 2 bytes and a slots number region having 2 bytes. The size of the tail region  418  is 4 bytes.  
         [0058]    Upon receipt of a request, the reservation system  306  atomically reserves a portion of the buffer  316  (Step  610 ). The atomic counter variable representing the next available slot  412  in the sequence (nextsequence) is maintained in control block, control region  404 . The counter&#39;s initial value is zero. To avoid the overhead of using system semaphores, latches or other expensive synchronization mechanisms, atomic operations are use when altering this variable. When a reservation is made, nextsequence is atomically incremented by the number of slots required, the value of nextsequence prior to the increment being assigned to the variable sequence to indicate the starting slot  412  of the reservation. The value of sequence is used to determine the actual address for the reservation in the memory  204  (Step  612 ) for providing to the writer  317 . On most hardware platforms, variables such an atomic counter variable can only be performed on word-sized boundaries. Consequently, the sequence number returned when the atomic counter variable is atomically incremented may represent an effective memory address that exceeds the actual address available memory addresses of the buffer  316 . For example, on a 32-bit platform, the atomic counter variable is a 32-bit integer, which could be an index for over four billion slots  412  having an addressable range of 2{circumflex over ( )}38 bytes (assuming the slot size is  64  or 2{circumflex over ( )}6). In practice, the buffer  316  is much smaller. To solve the problem of an adequate counting of a slot index, a modulo arithmetic is used to constrain the range of values of the sequence variable, between zero and a maxSlot-1. Using modulo arithmetic in an equation, the next sequence variable can be atomically incremented without additional range checking. This is important in case the next sequence value overflows or exceeds the total number of slots  412  in the buffer  316 . However, allowing the next sequence variable to overflow implies that the maximum number of slots value in the buffer  316  should always be a power of two. This ensures that no slots  412  are skipped when the next sequence value overflows.  
         [0059]    The slot index (slotindex) on first slot  412  for a reservation is calculated in accordance with the equation:  
         slotIndex=Sequence % max Slot  (2)  
         [0060]    Wherein: Sequence is a value of the atomic counter assigned for a current reservation; % is an operand of a modulo operation; MaxSlot variable is a total number slots  412  in the buffer  316  or the number slots  412  in the current chunk  410  if more than one chunk  410  is used in the reservation system  306 . This equation is used to calculate a slotIndex, which is a slot number in the buffer  316 .  
         [0061]    When the slotIndex is known, equation (3) is used to calculate an address of the slot  412  in the memory  204 .  
         Address=StartingAddress+(slotIndex*SlotSize)+ControlSize  (3)  
         [0062]    Wherein: StartingAddress is a starting address of the buffer  316  as defined in Step  604 ; SlotSize is a size in bytes of a slot  412  in the buffer  316  (e.g. 64 bytes), which is a constant value after a buffer initiation; and ControlSize is the size in bytes of a control region  404  in FIG. 4A.  
         [0063]    With the value of the variable Address thus calculated, the requesting writer  317  may then write information in the reserved region of the memory  204  at Address (not shown). The writer  317  then notifies the reservation system  306  of successful completion of writing (step  622 ). On receipt of a notification from a writer  317 , the reservation system  306  synchronizes the written information (step  624 ) by writing predetermined values into signature region  422  and tail region  418  of a reserved slot  412  for the writer  317 . The process of synchronization occurs in parallel with minimal effect on the performance of reservation steps from 608 to 612. Since the information is synchronized and the slots  412  are reserved for the writer  317 , the reservation in the reserved slot  412  is considered to be valid.  
         [0064]    Occasionally a reservation request cannot be initially accommodated because the number of slots  412  required by a writer  317  exceeds the number of contiguous slots  412  at the end of the buffer  316 . In the buffer wrapping mode, the reservation system  306  maintains its atomic reservation mechanism by automatically repeating the reservation as described further below.  
         [0065]    [0065]FIGS. 7A and 7B illustrate an example reservation of slots  412  using a repeated reservation. An exemplary buffer  700  comprises 8 slots  412 . Seven slots  412  from 0 to 6 have been reserved through four previous reservations FIG. 7A. (e.g., a reservation at the slot “0” for one slot  412 ; a reservation starting at slot “1” for three slots  412  including slots “1”, “2” and “3”; a reservation at slot “4” for one slot  412 ; and a reservation at slot “5” for two slots  412  comprising slots “5” and “6”). Slot “7” remains available for reservation and the value of the next sequence variable is equal to seven. If a writer  317  requests three slots  412 , the value of the next sequence variable may be atomically incremented to ten and the value of the slot index variable becomes equal to seven. A region comprising slots “7”, “0” and “1” has been reserved for a writer  317 . However, since the reserved region is not contiguous, the reservation is repeated by atomically incrementing the next sequence variable by three FIG. 7B. This results in a reservation of another region comprising slots “2”, “3” and “4”. The previously reserved region (slots “7”, “0” and “1”) is considered to be unused. It may be ignored during parsing, for example. Repeated reservation, while somewhat wasteful of slots  412 , facilitates reduced synchronization and thus reduces serialization.  
         [0066]    To avoid additional synchronisation on the nextSequence counter, double reservations and in fact all reservations are performed without determining whether the assigned slots  412  were still in use due to a previous reservation before a buffer wrap. If buffer wrapping is disabled and if the buffer is full, then the index of the next available slot  412  of the next reservation is equal to or greater than the maximum number of slots  412  (maxSlot) in the buffer  316 , and buffer truncation occurs. Once the buffer  316  is full the reservation system  306  prevents further reservations by flagging the truncated region  522  inside the structure of the dump file tail region  506 . Rather than provide a null address indicating a failed reservation, the reservation system  306  invokes a call back function supplied by writer  317 . This function could disable the writing activity of the writer  317  and reset or dump and reset the buffer. The location of the wasteland region  408  may be supplied following the callback. The wasteland region  408  can be ignored during parsing. A callback optimizes application (i.e. writer  317 ) code avoiding checks for null or special addresses.  
         [0067]    System  306  as is described above, can be enabled to facilitate dumping the stored data in the buffer  316  to a persistent storage such as hard drive. The file dumping can be performed continuously or occasionally.  
         [0068]    Continuous dumping creates an infinite buffer size because the reservation system  306  records reservations on the hard drive and prevents the buffer from overwriting previous reservations (wrapping). FIG. 6 shows continuous dump method  611 .  
         [0069]    Prior to the start of a continuous dumping process or thread, a dump file  500  FIG. 5 is created (step  626 ). The interface  308  then repeatedly queries the full count of chunk  410  (step  628 ), which is used to control each chunk  410 . When a chunk  410  is full, the interface  308  calculates the starting address (step  630 ) of the chunk  410  in the buffer (step  630 ). The entire chunk  410  is then written to the dump file  500 . Once the chunk  410  is recorded on the disk, the next chunk  410  can be examined for further writing to a dump file  500 , repeating all dumping processes as long as necessary. During continuous dumping mode the reservations of the writer  317  are blocked to ensure that no writer  317  can overwrite existing reservations in an un-dumped chunk  410 . If continuous dumping is enabled, the sequence number of each reservation is not checked because there is no requirement for sequence number range. As long as the synchronization value is appropriate, a reservation is considered to be valid and complete. Sequence numbers are ignored during the parsing of a continuous dump file  500 .  
         [0070]    The buffer  316  can be dumped to the disk at any time, in response to a request. FIG. 6 shows occasional dump method  605 . The reservation system  306  on receipt of a dump request (step  614 ) from the application  310 , returns buffer start address and size (step  616 ) to the application  310 , which is responsible for writing the data. Then the application  310  writes the content of the buffer and synchronization information as a dump file  500  FIG. 5 on the disk.  
         [0071]    As is described above, the system parsing logic expects valid reservations to fall within a specific sequence number range that is defined by formula (1). By altering the sequence values at run-time, the valid range of reservations can be changed. Thus, during the parsing stage the previously valid reservation may be considered old and may be ignored. This feature employs different techniques depending on whether buffer wrapping is enabled or disabled. If buffer wrapping is enabled, a sequence value is atomically incremented by maxSlots to invalidate all previous reservations in the buffer. After the sequence value is incremented, only new reservations may be considered valid and all other reservations may be considered invalid. A slot index of a reserved slot  412  remains the same (e.g., its location in the buffer remains the same).  
         [0072]    Reset method  607  is shown in FIG. 6. The reset request is received (step  618 ). If the buffer is reset, when buffer wrapping is disabled the system atomically adjusts the sequence value to the value that defines the next reservation at zero slot index (step  620 ). Once the slot index value equals or exceeds the maximum number of slots  412 , the buffer is considered to be full and the system stops any writing into the buffer. Therefore, when the buffer is cleared, the first reservation after the clearing, begins at slot index zero.  
         [0073]    The reservation system  306  does not serialize writing to the buffer  316 , making possible a situation in which a writer  317  makes a reservation but does not modify the data in the reserved slots  412  of the buffer  316  until the buffer  316  has been cleared or overwritten. The buffer  316  is more susceptible to this problem in the non-wrapping mode because during the process of clearing (which makes the next reservation slot index to always be “0”) a second writer  317  may be reserved in the same slots  412  that were previously reserved by the first writer  317 . The first writer  317  might use its reserved slots  412  at any time. If the second writer  317  modifies and synchronizes the slots  412  after the first writer  317  has modified the same slots  412 , this creates a situation in which overwrites the new data from was reserved and sequence number. When the buffer is dumped and parsed, the data in the rewritten slots  412  may be ignored and only slots  412  that follow after the rewritten slots  412  may be considered valid.  
         [0074]    When buffer wrapping is enabled, the rewriting problem is minimized because the slot index may not be reset back to 0. As a result, the first writer  317  would likely never overwrite new data, especially if the buffer size is substantially large.  
         [0075]    When buffer wrapping is allowed, the buffer may be wrapped and previous reservations may be overwritten by new reservations. It is desirable for the parsing stage to know if a buffer has been wrapped. In most situations, the parsing logic can detect when a buffer has wrapped by comparing the next sequence value stored the next sequence region  516  in the dump file tail region  506  with an initial sequence value stored in the initial sequence region  520 , which indicates the oldest possible reservation sequence number. Initially the value of the initial sequence value is zero. If the difference between the sequence value and the initial sequence value exceeds the value of maxSlots, the buffer was wrapped. If buffer wrapping is disabled, the initial sequence value is meaningless. A situation may arise where the reservation system can not detect whether the buffer has wrapped. This occurs when the next sequence value overflows. As an example, in a buffer having 8 slots  412 , a large number of reservations are made. Consequently, the next sequence value may eventually overflow. If this occurs and the buffer is dumped, the embedded in the tail structure of the dump file  500  the next sequence value might equal 2. Since the difference between the initial sequence value and next sequence value is less than maxSlots, the conclusion that the buffer has wrapped may be made; this conclusion would be incorrect because the buffer has wrapped numerous times.  
         [0076]    Conversely, when buffer wrapping is disabled, buffer truncation can occur. Once the buffer is full, the buffer is prevented from future reservations. This scenario is detected and flagged inside the dump file tail region  506  (truncated region  522 ). If the slot index of the next reservation is greater than or equal to the maxSlots the buffer considered truncated because further reservations cannot be accommodated.  
         [0077]    A reservation system  306  in accordance with the present invention serves to reduce writer synchronization in an application sharing memory among a plurality of writers. The use of an atomic counter to indicate the next available portion of memory within a synchronization mechanism ensures that individual writers are temporarily assigned unique portions of the memory efficiently.  
         [0078]    It is to be understood that the specific embodiments of the invention that have been described are merely illustrative of certain application of the principle of the present invention. Numerous modifications may be made to the reduced synchronization reservation system and method for a shared memory buffer invention described herein without departing from the spirit and scope of the present invention.