flang/runtime/unit-map.cpp

   1 //===-- runtime/unit-map.cpp ----------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "unit-map.h"
  10
  11 namespace Fortran::runtime::io {
  12
  13 void UnitMap::Initialize() {
  14   if (!isInitialized_) {
  15     freeNewUnits_.InitializeState();
  16     // Unit number -1 is reserved.
  17     // The unit numbers are pushed in reverse order so that the first
  18     // ones to be popped will be small and suitable for use as kind=1
  19     // integers.
  20     for (int j{freeNewUnits_.maxValue}; j > 1; --j) {
  21       freeNewUnits_.Add(j);
  22     }
  23     isInitialized_ = true;
  24   }
  25 }
  26
  27 // See 12.5.6.12 in Fortran 2018.  NEWUNIT= unit numbers are negative,
  28 // and not equal to -1 (or ERROR_UNIT, if it were negative, which it isn't.)
  29 ExternalFileUnit &UnitMap::NewUnit(const Terminator &terminator) {
  30   CriticalSection critical{lock_};
  31   Initialize();
  32   std::optional<int> n{freeNewUnits_.PopValue()};
  33   if (!n) {
  34     n = emergencyNewUnit_++;
  35   }
  36   return Create(-*n, terminator);
  37 }
  38
  39 ExternalFileUnit *UnitMap::LookUpForClose(int n) {
  40   CriticalSection critical{lock_};
  41   Chain *previous{nullptr};
  42   int hash{Hash(n)};
  43   for (Chain *p{bucket_[hash].get()}; p; previous = p, p = p->next.get()) {
  44     if (p->unit.unitNumber() == n) {
  45       if (previous) {
  46         previous->next.swap(p->next);
  47       } else {
  48         bucket_[hash].swap(p->next);
  49       }
  50       // p->next.get() == p at this point; the next swap pushes p on closing_
  51       closing_.swap(p->next);
  52       return &p->unit;
  53     }
  54   }
  55   return nullptr;
  56 }
  57
  58 void UnitMap::DestroyClosed(ExternalFileUnit &unit) {
  59   Chain *p{nullptr};
  60   {
  61     CriticalSection critical{lock_};
  62     Chain *previous{nullptr};
  63     for (p = closing_.get(); p; previous = p, p = p->next.get()) {
  64       if (&p->unit == &unit) {
  65         int n{unit.unitNumber()};
  66         if (n <= -2) {
  67           freeNewUnits_.Add(-n);
  68         }
  69         if (previous) {
  70           previous->next.swap(p->next);
  71         } else {
  72           closing_.swap(p->next);
  73         }
  74         break;
  75       }
  76     }
  77   }
  78   if (p) {
  79     p->unit.~ExternalFileUnit();
  80     FreeMemory(p);
  81   }
  82 }
  83
  84 void UnitMap::CloseAll(IoErrorHandler &handler) {
  85   // Extract units from the map so they can be closed
  86   // without holding lock_.
  87   OwningPtr<Chain> closeList;
  88   {
  89     CriticalSection critical{lock_};
  90     for (int j{0}; j < buckets_; ++j) {
  91       while (Chain * p{bucket_[j].get()}) {
  92         bucket_[j].swap(p->next); // pops p from head of bucket list
  93         closeList.swap(p->next); // pushes p to closeList
  94       }
  95     }
  96   }
  97   while (Chain * p{closeList.get()}) {
  98     closeList.swap(p->next); // pops p from head of closeList
  99     p->unit.CloseUnit(CloseStatus::Keep, handler);
 100     p->unit.~ExternalFileUnit();
 101     FreeMemory(p);
 102   }
 103 }
 104
 105 void UnitMap::FlushAll(IoErrorHandler &handler) {
 106   CriticalSection critical{lock_};
 107   for (int j{0}; j < buckets_; ++j) {
 108     for (Chain *p{bucket_[j].get()}; p; p = p->next.get()) {
 109       p->unit.FlushOutput(handler);
 110     }
 111   }
 112 }
 113
 114 ExternalFileUnit *UnitMap::Find(const char *path, std::size_t pathLen) {
 115   if (path) {
 116     // TODO: Faster data structure
 117     for (int j{0}; j < buckets_; ++j) {
 118       for (Chain *p{bucket_[j].get()}; p; p = p->next.get()) {
 119         if (p->unit.path() && p->unit.pathLength() == pathLen &&
 120             std::memcmp(p->unit.path(), path, pathLen) == 0) {
 121           return &p->unit;
 122         }
 123       }
 124     }
 125   }
 126   return nullptr;
 127 }
 128
 129 ExternalFileUnit &UnitMap::Create(int n, const Terminator &terminator) {
 130   Chain &chain{*New<Chain>{terminator}(n).release()};
 131   chain.next.reset(&chain);
 132   bucket_[Hash(n)].swap(chain.next); // pushes new node as list head
 133   return chain.unit;
 134 }
 135
 136 } // namespace Fortran::runtime::io