Tile.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  Tile.h MFM grid segment
  Copyright (C) 2014 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef TILE_H
#define TILE_H

#include <pthread.h>
#include "Dirs.h"
#include "Random.h"  /* for Random */
#include "Packet.h"
#include "Point.h"
#include "EventWindow.h"
#include "ElementTable.h"
#include "Connection.h"
#include "ThreadPauser.h"
#include "OverflowableCharBufferByteSink.h"  /* for OString16 */

namespace MFM
{
#define IS_OWNED_CONNECTION(X) ((X) - Dirs::EAST >= 0 && (X) - Dirs::EAST < 4)

#define BACKGROUND_RADIATION_SITE_ODDS 1000
#define BACKGROUND_RADIATION_BIT_ODDS 100

  typedef enum
  {
    REGION_CACHE   = 0,
    REGION_SHARED  = 1,
    REGION_VISIBLE = 2,
    REGION_HIDDEN  = 3,
    REGION_COUNT
  }TileRegion;

  typedef enum
  {
    LOCKTYPE_NONE   = 0,
    LOCKTYPE_SINGLE = 1,
    LOCKTYPE_TRIPLE = 2,
    LOCKTYPE_COUNT
  }LockType;

  template <class CC>
  class Tile
  {
    // Extract short names for parameter types
    typedef typename CC::ATOM_TYPE T;
    typedef typename CC::PARAM_CONFIG P;
    enum { R = P::EVENT_WINDOW_RADIUS };
    enum { W = P::TILE_WIDTH };
    enum { B = P::ELEMENT_TABLE_BITS };

  public:

    static const u32 EVENT_WINDOW_RADIUS = R;

    static const u32 TILE_WIDTH = W;

    static const u32 TILE_SIZE = TILE_WIDTH * TILE_WIDTH;

    static const u32 ELEMENT_TABLE_BITS = B;  // Currently hard-coded!
    static const u32 ELEMENT_TABLE_SIZE = 1u<<ELEMENT_TABLE_BITS;

    static const u32 OWNED_SIDE = TILE_WIDTH-2*R;

  private:
    OString16 m_label;

    MFMErrorEnvironmentPointer_t m_errorEnvironmentStackTop;

    bool m_backgroundRadiationEnabled;

    bool m_ignoreThreadingProblems;

#if 0

    u32 m_writeFailureOdds;
#endif

    ElementTable<CC> elementTable;

    Random m_random;

    u64 m_eventsExecuted;

    u32 m_eventsFailed;

    u32 m_failuresErased;

    u64 m_regionEvents[REGION_COUNT];

    u64 m_lockEvents[LOCKTYPE_COUNT];

    // Quick hack counts trying to debug vanishing atoms
    u64 m_lockAttempts;
    u64 m_lockAttemptsSucceeded;

    u64 m_siteEvents[OWNED_SIDE][OWNED_SIDE];

    u64 m_lastChangedEventNumber[OWNED_SIDE][OWNED_SIDE];

    friend class EventWindow<CC>;

    T m_atoms[TILE_WIDTH][TILE_WIDTH];

    s32 m_atomCount[ELEMENT_TABLE_SIZE];

    bool m_needRecount;

    s32 m_illegalAtomCount;

    SPoint m_lastExecutedAtom;

    EventWindow<CC> m_executingWindow;

    Connection* m_connections[8];

    bool m_iLocked[8];

    bool m_isFnWing;
    u32 m_curFnWingDirWaitWord;
    u32 m_origFnWingDirWaitWord;

    bool m_isA2PRed;

    bool m_isGSBIsw;

    Connection m_ownedConnections[4];

    pthread_t m_thread;

    bool m_threadInitialized;

    bool IsPausedOrOwner()
    {
      return m_threadPauser.GetStateNonblocking()==THREADSTATE_PAUSED
        || pthread_equal(pthread_self(), m_thread);
    }

#if 0

    bool m_threadPaused;
#endif

    bool m_executeOwnEvents;

    ThreadPauser m_threadPauser;

    u8 m_generation;

    bool IsOwnedConnection(Dir dir);

    void CreateRandomWindow();

    void CreateWindowAt(const SPoint& pt);

    u32 SendRelevantAtoms();

    void SendEndEventPackets(u32 dirWaitWord);


    static SPoint GetNeighborLoc(Dir neighbor, const SPoint& atomLoc);

    void SendAtom(Dir neighbor, SPoint& atomLoc);

    bool TryLock(Dir connectionDir);

    bool TryLockCorner(Dir cornerDir);

    bool LockRegion(Dir regionDir);

    void UnlockCorner(Dir corner);

    void UnlockDir(Dir dir) ;

    void UnlockRegion(Dir regionDir);

    TileRegion RegionFromIndex(const u32 index);

    TileRegion RegionIn(const SPoint& pt);

    inline bool IsInHidden(const SPoint& pt);

    void DoEvent(bool locked, Dir lockRegion);

   public:
    void ReportTileStatus(Logger::Level level);

    const char * GetLabel()
    {
      return m_label.GetZString();
    }

    OString16 & GetLabelPrinter()
    {
      return m_label;
    }

    Tile();

    void SetIgnoreThreadingProblems(bool value);

    void Reinit();

    void ClearAtoms();

    void CheckCacheFromDir(Dir direction, const Tile & otherTile);

    void SetGeneration(u8 generation)
    {
      m_generation = generation;
    }

    u8 GetGeneration() const
    {
      return m_generation;
    }

    void Connect(Tile<CC>& other, Dir toCache);

    Connection* GetConnection(Dir cache);

    u32 GetSites() const
    {
      return OWNED_SIDE*OWNED_SIDE;
    }

    u32 GetTileWidth()
    {
      return TILE_WIDTH;
    }

    Random & GetRandom();

    ElementTable<CC> & GetElementTable()
    {
      return elementTable;
    }

    const ElementTable<CC> & GetElementTable() const
    {
      return elementTable;
    }

    const Element<CC> * GetElement(const u32 elementType) const
    {
      return elementTable.Lookup(elementType);
    }

    inline bool IsConnected(Dir dir) const;

    bool HasAnyConnections(Dir regionDir) const;

    static inline bool IsInCache(const SPoint& pt);

    static inline bool IsOwnedSite(const SPoint & location);


    static inline bool IsInTile(const SPoint& pt);

    static inline bool IsInUncachedTile(const SPoint& pt);

    bool IsLiveSite(const SPoint & location) const;

    u64 GetEventsExecuted() const
    {
      return m_eventsExecuted;
    }

    Dir RegionAt(const SPoint& pt, u32 reach) const;

    Dir CacheAt(const SPoint& pt) const;

    Dir SharedAt(const SPoint& pt) const;

    Dir VisibleAt(const SPoint& pt) const;

    const T* GetAtom(const SPoint& pt) const
    {
      return GetAtom(pt.GetX(), pt.GetY());
    }

    T* GetWritableAtom(const SPoint& pt)
    {
      return GetWritableAtom(pt.GetX(), pt.GetY());
    }

    const T* GetAtom(s32 x, s32 y) const
    {
      if (((u32) x) >= TILE_WIDTH || ((u32) y) >= TILE_WIDTH)
      {
        FAIL(ARRAY_INDEX_OUT_OF_BOUNDS);
      }
      return &m_atoms[x][y];
    }

    T* GetWritableAtom(s32 x, s32 y)
    {
      if (((u32) x) >= TILE_WIDTH || ((u32) y) >= TILE_WIDTH)
      {
        FAIL(ARRAY_INDEX_OUT_OF_BOUNDS);
      }
      return &m_atoms[x][y];
    }

    const T* GetUncachedAtom(const SPoint& pt) const
    {
      return GetUncachedAtom(pt.GetX(), pt.GetY());
    }

    const T* GetUncachedAtom(s32 x, s32 y) const
    {
      return GetAtom(x+R, y+R);
    }


    u64 GetUncachedSiteEvents(const SPoint site) const ;

    u32 GetUncachedWriteAge(const SPoint site) const ;

    void SendAcknowledgmentPacket(Packet<T>& packet);

    void ReceivePacket(Packet<T>& packet);

#if 0 /* Doesn't exist? */

    Packet<T>* NextPacket();
#endif

    void FillLastExecutedAtom(SPoint& out);

    void PlaceAtom(const T& atom, const SPoint& pt);

    void PlaceInternalAtom(const T& atom, const SPoint& pt)
    {
      PlaceAtom(atom,pt+SPoint(R,R));
    }

    bool FlushAndWaitOnAllBuffers(u32 dirWaitWord);

    void ReportIfBuffersAreNonEmpty();

    void SetExecuteOwnEvents(bool value)
    {
      m_executeOwnEvents = value;
    }

    bool GetExecutingOwnEvents() const
    {
      return m_executeOwnEvents;
    }

    void Execute();

    static void* ExecuteThreadHelper(void* tilePtr);

    u32 GetAtomCount(ElementType atomType) const;

    void InternalPutAtom(const T & atom, s32 x, s32 y);

    void SetAtomCount(ElementType atomType, s32 count);

    void Start();

    void Pause();

    bool IsRunReady()
    {
      return m_threadPauser.IsRunReady();
    }

    void Run()
    {
      m_threadPauser.Run();
    }

    bool IsPauseReady();

    void RequestPause();

    void IncrAtomCount(ElementType atomType, s32 delta);

    void AssertValidAtomCounts() const;

    void RecountAtomsIfNeeded();

    void RecountAtoms();

    u64 WriteEPSRasterLine(ByteSink & outstrm, u32 lineIdx);

    void RegisterElement(const Element<CC> & anElement)
    {
      elementTable.RegisterElement(anElement);
    }

    void SetBackgroundRadiation(bool value)
    {
      m_backgroundRadiationEnabled = value;
    }

    inline void SingleXRay();

    inline void SingleXRay(u32 x, u32 y);

    void XRay(u32 siteOdds, u32 bitOdds);

  };
} /* namespace MFM */

#include "Tile.tcc"

#endif /*TILE_H*/