home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

lw_lock.h

Go to the documentation of this file.

//  Copyright (C) 1995-2002 Brad Wilson
//
//  This material is provided "as is", with absolutely no warranty
//  expressed or implied. Any use is at your own risk. Permission to
//  use or copy this software for any purpose is hereby granted without
//  fee, provided the above notices are retained on all copies.
//  Permission to modify the code and to distribute modified code is
//  granted, provided the above notices are retained, and a notice that
//  the code was modified is included with the above copyright notice.
//

/*
 * Copyright © 2002 Sofus Mortensen
 *
 * This material is provided "as is", with absolutely no warranty
 * expressed or implied. Any use is at your own risk. Permission to
 * use or copy this software for any purpose is hereby granted without
 * fee, provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is
 * granted, provided the above notices are retained, and a notice that
 * the code was modified is included with the above copyright notice.
 *
 * This header is part of comet.
 * http://www.lambdasoft.dk/comet
 */

#include <comet/config.h>
#include <comet/assert.h>

#include <windows.h>

namespace comet {

#ifndef COMET_LW_LOCK_SPIN
#define COMET_LW_LOCK_SPIN Sleep(0)
#endif


        class lw_lock
        {
        //  Interface

        public:
                lw_lock()
                {
                        reader_count_ = 0;
                        writer_count_ = 0;
                }

                ~lw_lock()
                {
                        COMET_ASSERT( reader_count_ == 0 );
                        COMET_ASSERT( writer_count_ == 0 );
                }

                void enter_reader() const
                {
                        while( 1 )
                        {
                                //  If there's a writer already, spin without unnecessarily
                                //  interlocking the CPUs

                                if( writer_count_ != 0 )
                                {
                                        COMET_LW_LOCK_SPIN;
                                        continue;
                                }

                                //  Add to the readers list

                                InterlockedIncrement((long *)&reader_count_ );

                                //  Check for writers again (we may have been pre-empted). If
                                //  there are no writers writing or waiting, then we're done.

                                if( writer_count_ == 0 )
                                        break;

                                //  Remove from the readers list, spin, try again

                                InterlockedDecrement((long *)&reader_count_ );
                                COMET_LW_LOCK_SPIN;
                        }
                }

                void leave_reader() const
                {
                        InterlockedDecrement((long *)&reader_count_ );
                }

                void enter_writer()
                {
                        //  See if we can become the writer (expensive, because it inter-
                        //  locks the CPUs, so writing should be an infrequent process)

                        while( InterlockedExchange((long *)&writer_count_, 1 ) == 1 )
                        {
                                COMET_LW_LOCK_SPIN;
                        }

                        //  Now we're the writer, but there may be outstanding readers.
                        //  Spin until there aren't any more; new readers will wait now
                        //  that we're the writer.

                        while( reader_count_ != 0 )
                        {
                                COMET_LW_LOCK_SPIN;
                        }
                }

                void leave_writer()
                {
                        writer_count_ = 0;
                }

        //  Implementation

        private:
                mutable long volatile reader_count_;
                mutable long volatile writer_count_;

                // Declare class non-copyable
                lw_lock(const lw_lock&);
                lw_lock& operator=(const lw_lock&);
        };

        class auto_reader_lock {
        public:
                explicit auto_reader_lock(const lw_lock& cs) : cs_(cs) {
                        cs_.enter_reader();
                }

                ~auto_reader_lock() {
                        cs_.leave_reader();
                }

        private:
                auto_reader_lock& operator=(const auto_reader_lock&);
                auto_reader_lock(const auto_reader_lock&);

                const lw_lock& cs_;
        };

        class auto_writer_lock {
        public:
                explicit auto_writer_lock(lw_lock& cs) : cs_(cs) {
                        cs_.enter_writer();
                }

                ~auto_writer_lock() {
                        cs_.leave_writer();
                }

        private:
                auto_writer_lock& operator=(const auto_writer_lock&);
                auto_writer_lock(const auto_writer_lock&);

                lw_lock& cs_;
        };

}

Copyright 2002 Sofus Mortensen. All rights reserved.