Jump to content

FredS

Members
 View Profile  See their activity

  • Content Count

    408

  • Joined

  • Last visited

  • Days Won

    4

Posts posted by FredS

  1. Posted

    3 hours ago, Mark Williams said:

    The references to "Shell32" throw up unrecognised errors

    shell32 is declared in Winapi.ShlObj in the implementation section. 

    const
  shell32 = 'shell32.dll';

     

    You in Berlin or UP, or something else?

    You know asking Qs without supplying sufficient information simply leads to what you see here..

     

  4. Posted

    1 hour ago, David Hoyle said:

    {$IFNDEF DEBUG} around the inline directive

    With include files one can change the inline option and skip all those IFNDEFs, tested with Berlin and up.
    In this case the include file includes a CustomInclude.inc, which is part of the project. This makes it simple to edit in the IDE as required.

      

    /// <remarks>
///    NOTE:  You can override this in CustomInclude.inc, but it requires a Build
///           and won't update the Blue Dots
/// </remarks>
{$IFNDEF RELEASE}
  {-$INLINE OFF} // un-comment as needed
{$ENDIF RELEASE}

     

    • Like 2
    • Thanks 2

  18. Posted · Edited by FredS
    No reverse in https://en.delphipraxis.net/topic/1761-is-there-any-currency-to-words-routine-for-delphi/

    1 hour ago, Pawel Piotrowski said:

    NOT thread Safe

     

    Been on the back of my mind since I read Marco's book but I never had to deal with strings where a lock wasn't used.

    However, if the main thread (mt) only reads and a worker thread (wt) only writes this should be fine.

     

    The way I see this is that when the wt writes to a string variable if first makes a reference copy of the original. If the mt reads that string it gets the old value while its being written to.
    Once the write lock is off the string var now points to the new string and when the mt tries to read it the next time around it gets a reference to that string.

     

    A quick test is below, I used a Cursive Number method to make the string more complex for the test, I know a version of that is available here somewhere.
    Unfortunately the version available does not reverse from Text. But you can simply replace these three calls with CurrToStr/StrToCurr.

     

    Guess I  could let that run a bit longer and see if there are any collisions..

      

    //MMWIN:MEMBERSCOPY
unit _MM_Copy_Buffer_;

interface

type
  THelperTests = class(TObject)
  public
    [Test]
    [TestCase('10k', '10000')]
    procedure TestStringThreadSafe(Iterations: Integer);
  end;


implementation

procedure THelperTests.TestStringThreadSafe(Iterations: Integer);
var
  c, LastReadC : Currency;
  s : string;
  HasTerminated : Boolean;
  i : integer;
const IncBy = 1000;
begin
//  Assert.IsTrue(TAtomic.IsNatural(c, SizeOf(c)), 'Currency will only work in x64');

  c := 1000.34;
  s := TCursiveNumbers.ToText(c);

  {- Reading }
  TThread.CreateAnonymousThread( procedure
    var rS : string; CurrentC  : Currency;
    begin
      LastReadC := c;
      rS := s;
      while not HasTerminated do
        if rS <> S then begin
          rS := S;
          CurrentC := TCursiveNumbers.ToCurrency(rS);
          Assert.AreEqual(LastReadC + IncBy, CurrentC, 'Oops');
          LastReadC := CurrentC;
        end;
    end).Start;

  for i := 0 to Iterations do begin
    c := c + IncBy;
    s := TCursiveNumbers.ToText(c);
    Sleep(1); // give the slice away
  end;

  HasTerminated := True;
  Sleep(2);
  Assert.AreEqual(c, LastReadC, 'Reading does not match writing');
  Log(S);
end;


end.

     

     

  21. Posted · Edited by FredS

    7 hours ago, dummzeuch said:

    What about a packed record

    OK, simple variables and lets add default aligned, but that was not the question.
     

    As you can see with the TSrwLock declaration, the FIRST variable in a record is always properly aligned.

     

    I use this during initialization: 

    //MMWIN:MEMBERSCOPY
unit _MM_Copy_Buffer_;

interface

type
  TAtomic = record
     /// <summary>
     ///   Assures {$A8} or {$A+} state
     /// </summary>
     /// <seealso href="https://stackoverflow.com/questions/829235/ifopt-a4">
     ///   {$IFOPT A4}?
     /// </seealso>
    class constructor Create;
  end;


implementation

 { TAtomic }

class constructor TAtomic.Create;
type
  TTestRec = record
    A: Byte;
    B: Int64;
  end;
begin
  // In the {$A8} or {$A+} state, fields in record types that are declared without the packed modifier and fields in class structures are aligned on quadword boundaries.
{$IF SIZEOF(TTestRec) <> 16}
  'App must be compiled in A8 mode'
{$IFEND}
end;


end.

     

  23. Posted

    1 minute ago, Uwe Raabe said:

    Perhaps the ISO installer requires

    I checked for installation instructions and found none, attempted an install and failed.

    Enough new EMB tech for now.. 🙂

     

    BTW: Its difficult to compare previous installers since they change (and fail) frequently but in the last few ISO versions it prompted for an uninstall before installing.

     

    Will see how that goes on my laptop later, its setup using 'Web Installer'..

     

    • Sad 1
×