Changeset 376

Show
Ignore:
Timestamp:
06/08/07 10:45:23 (2 years ago)
Author:
blackhedd
Message:

refactored the "close descriptor" mechanism, preparatory to making epoll-related changes.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • version_0/ext/ed.cpp

    r373 r376  
    4545 
    4646EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em): 
     47        bCloseNow (false), 
     48        bCloseAfterWriting (false), 
    4749        EventCallback (NULL), 
    4850        LastRead (0), 
    4951        LastWritten (0), 
    5052        MySocket (sd), 
    51         bCloseNow (false), 
    52         bCloseAfterWriting (false), 
    5353        bCallbackUnbind (true), 
    5454        MyEventMachine (em) 
     
    149149void EventableDescriptor::ScheduleClose (bool after_writing) 
    150150{ 
     151        // KEEP THIS SYNCHRONIZED WITH ::IsCloseScheduled. 
    151152        if (after_writing) 
    152153                bCloseAfterWriting = true; 
    153154        else 
    154155                bCloseNow = true; 
     156} 
     157 
     158 
     159/************************************* 
     160EventableDescriptor::IsCloseScheduled 
     161*************************************/ 
     162 
     163bool EventableDescriptor::IsCloseScheduled() 
     164{ 
     165        // KEEP THIS SYNCHRONIZED WITH ::ScheduleClose. 
     166        return (bCloseNow || bCloseAfterWriting); 
    155167} 
    156168 
     
    274286        // (Well, not so bad, small pages are coalesced in ::Write) 
    275287 
    276         if (bCloseNow || bCloseAfterWriting) 
     288        if (IsCloseScheduled()) 
     289        //if (bCloseNow || bCloseAfterWriting) 
    277290                return 0; 
    278291 
     
    421434                // If we read no data on a socket that selected readable, 
    422435                // it generally means the other end closed the connection gracefully. 
    423                 bCloseNow = true; 
     436                ScheduleClose (false); 
     437                //bCloseNow = true; 
    424438        } 
    425439 
     
    502516                } 
    503517                else 
    504                         bCloseNow = true; 
     518                        ScheduleClose (false); 
     519                        //bCloseNow = true; 
    505520        } 
    506521        else { 
     
    685700        if (bConnectPending) { 
    686701                if ((gCurrentLoopTime - CreatedAt) >= PendingConnectTimeout) 
    687                         bCloseNow = true; 
     702                        ScheduleClose (false); 
     703                        //bCloseNow = true; 
    688704        } 
    689705        else { 
    690706                if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout)) 
    691                         bCloseNow = true; 
     707                        ScheduleClose (false); 
     708                        //bCloseNow = true; 
    692709        } 
    693710} 
     
    888905        // Close it if its inactivity timer has expired. 
    889906 
    890   if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout)) 
    891                 bCloseNow = true; 
     907        if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout)) 
     908                ScheduleClose (false); 
     909                //bCloseNow = true; 
    892910} 
    893911 
     
    10381056        // That means it needs to move to a common ancestor. 
    10391057 
    1040         if (bCloseNow || bCloseAfterWriting) 
     1058        if (IsCloseScheduled()) 
     1059        //if (bCloseNow || bCloseAfterWriting) 
    10411060                return 0; 
    10421061 
     
    10691088        // TODO: Refactor this so there's no overlap with SendOutboundData. 
    10701089 
    1071         if (bCloseNow || bCloseAfterWriting) 
     1090        if (IsCloseScheduled()) 
     1091        //if (bCloseNow || bCloseAfterWriting) 
    10721092                return 0; 
    10731093 
  • version_0/ext/ed.h

    r372 r376  
    5858 
    5959                void ScheduleClose (bool after_writing); 
     60                bool IsCloseScheduled(); 
    6061 
    6162                void SetEventCallback (void (*cb)(const char*, int, const char*, int)); 
     
    7374                struct epoll_event *GetEpollEvent() { return &EpollEvent; } 
    7475                #endif 
     76 
     77        private: 
     78                bool bCloseNow; 
     79                bool bCloseAfterWriting; 
    7580 
    7681        protected: 
     
    8590                time_t LastWritten; 
    8691                int MySocket; 
    87                 bool bCloseNow; 
    88                 bool bCloseAfterWriting; 
    8992                bool bCallbackUnbind; 
    9093 
  • version_0/ext/pipe.cpp

    r372 r376  
    133133                // If we read no data on a socket that selected readable, 
    134134                // it generally means the other end closed the connection gracefully. 
    135                 bCloseNow = true; 
     135                ScheduleClose (false); 
     136                //bCloseNow = true; 
    136137        } 
    137138 
     
    208209        // If an inactivity timeout is defined, then check for it. 
    209210        if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout)) 
    210                 bCloseNow = true; 
     211                ScheduleClose (false); 
     212                //bCloseNow = true; 
    211213} 
    212214 
     
    247249int PipeDescriptor::SendOutboundData (const char *data, int length) 
    248250{ 
    249         if (bCloseNow || bCloseAfterWriting) 
     251        //if (bCloseNow || bCloseAfterWriting) 
     252        if (IsCloseScheduled()) 
    250253                return 0; 
    251254