I was implementing an algorithm in Swift Beta and noticed that the performance was very poor. After digging deeper I realized that one of the bottlenecks was something as simple as sorting arrays. The relevant part is here:

    let n = 1000000
    var x =  [Int](repeating: 0, count: n)
    for i in 0..&lt;n {
        x[i] = random()
    }
    // start clock here
    let y = sort(x)
    // stop clock here

In C++, a similar operation takes **0.06s** on my computer.

In Python, it takes **0.6s** (no tricks, just y = sorted(x) for a list of integers).

In Swift it takes **6s** if I compile it with the following command:

    xcrun swift -O3 -sdk `xcrun --show-sdk-path --sdk macosx`

And it takes as much as **88s** if I compile it with the following command:

    xcrun swift -O0 -sdk `xcrun --show-sdk-path --sdk macosx`

Timings in Xcode with &quot;Release&quot; vs. &quot;Debug&quot; builds are similar.

What is wrong here? I could understand some performance loss in comparison with C++, but not a 10-fold slowdown in comparison with pure Python.

----

**Edit:** weather noticed that changing `-O3` to `-Ofast` makes this code run almost as fast as the C++ version! However, `-Ofast` changes the semantics of the language a lot — in my testing, it **disabled the checks for integer overflows and array indexing overflows**. For example, with `-Ofast` the following Swift code runs silently without crashing (and prints out some garbage):

    let n = 10000000
    print(n*n*n*n*n)
    let x =  [Int](repeating: 10, count: n)
    print(x[n])

So `-Ofast` is not what we want; the whole point of Swift is that we have the safety nets in place. Of course, the safety nets have some impact on the performance, but they should not make the programs 100 times slower. Remember that Java already checks for array bounds, and in typical cases, the slowdown is by a factor much less than 2. And in Clang and GCC we have got `-ftrapv` for checking (signed) integer overflows, and it is not that slow, either.

Hence the question: how can we get reasonable performance in Swift without losing the safety nets?

----

**Edit 2:** I did some more benchmarking, with very simple loops along the lines of

    for i in 0..&lt;n {
        x[i] = x[i] ^ 12345678
    }

(Here the xor operation is there just so that I can more easily find the relevant loop in the assembly code. I tried to pick an operation that is easy to spot but also &quot;harmless&quot; in the sense that it should not require any checks related to integer overflows.)

Again, there was a huge difference in the performance between `-O3` and `-Ofast`. So I had a look at the assembly code:

- With `-Ofast` I get pretty much what I would expect. The relevant part is a loop with 5 machine language instructions.

- With `-O3` I get something that was beyond my wildest imagination. The inner loop spans 88 lines of assembly code. I did not try to understand all of it, but the most suspicious parts are 13 invocations of &quot;callq _swift_retain&quot; and another 13 invocations of &quot;callq _swift_release&quot;. That is, **26 subroutine calls in the inner loop**!

----

**Edit 3:** In comments, Ferruccio asked for benchmarks that are fair in the sense that they do not rely on built-in functions (e.g. sort). I think the following program is a fairly good example:

    let n = 10000
    var x = [Int](repeating: 1, count: n)
    for i in 0..&lt;n {
        for j in 0..&lt;n {
            x[i] = x[j]
        }
    }

There is no arithmetic, so we do not need to worry about integer overflows. The only thing that we do is just lots of array references. And the results are here—Swift -O3 loses by a factor almost 500 in comparison with -Ofast:

- C++ -O3: **0.05 s**
- C++ -O0: 0.4 s
- Java: **0.2 s**
- Python with PyPy: 0.5 s
- Python: **12 s**
- Swift -Ofast: 0.05 s
- Swift -O3: **23 s**
- Swift -O0: 443 s

(If you are concerned that the compiler might optimize out the pointless loops entirely, you can change it to e.g. `x[i] ^= x[j]`, and add a print statement that outputs `x[0]`. This does not change anything; the timings will be very similar.)

And yes, here the Python implementation was a stupid pure Python implementation with a list of ints and nested for loops. It should be **much** slower than unoptimized Swift. Something seems to be seriously broken with Swift and array indexing.

----

**Edit 4:** These issues (as well as some other performance issues) seems to have been fixed in Xcode 6 beta 5.

For sorting, I now have the following timings:

- clang++ -O3: 0.06 s
- swiftc -Ofast: 0.1 s
- swiftc -O: 0.1 s
- swiftc: 4 s

For nested loops:

- clang++ -O3: 0.06 s
- swiftc -Ofast: 0.3 s
- swiftc -O: 0.4 s
- swiftc: 540 s

It seems that there is no reason anymore to use the unsafe `-Ofast` (a.k.a. `-Ounchecked`); plain `-O` produces equally good code.


Swift Beta performance: sorting arrays

I have a working app and I&#39;m working on converting it to ARC in Xcode 4.2. One of the pre-check warnings involves capturing `self` strongly in a block leading to a retain cycle. I&#39;ve made a simple code sample to illustrate the issue. I believe I understand what this means but I&#39;m not sure the &quot;correct&quot; or recommended way to implement this type of scenario.

 - self is an instance of class MyAPI
 - the code below is simplified to show only the interactions with the objects and blocks relevant to my question
 - assume that MyAPI gets data from a remote source and MyDataProcessor works on that data and produces an output
 - the processor is configured with blocks to communicate progress &amp; state

code sample:

    // code sample
    self.delegate = aDelegate;
    
    self.dataProcessor = [[MyDataProcessor alloc] init];
    
    self.dataProcessor.progress = ^(CGFloat percentComplete) {
        [self.delegate myAPI:self isProcessingWithProgress:percentComplete];
    };
    
    self.dataProcessor.completion = ^{
        [self.delegate myAPIDidFinish:self];
        self.dataProcessor = nil;
    };
    
    // start the processor - processing happens asynchronously and the processor is released in the completion block
    [self.dataProcessor startProcessing];

Question: what am I doing &quot;wrong&quot; and/or how should this be modified to conform to ARC conventions?

How do I avoid capturing self in blocks when implementing an API?

&gt; **Possible Duplicate:**  
&gt; [Removing multiple files from a Git repo that have already been deleted from disk](https://stackoverflow.com/questions/492558/removing-multiple-files-from-a-git-repo-that-have-already-been-deleted-from-disk)  

&lt;!-- End of automatically inserted text --&gt;

If I delete some files from the disk they come up as deleted like so in the Git repo:

    C:\git\bc&gt;git status
    # On branch tracking2
    # Changed but not updated:
    #   (use &quot;git add/rm &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #       deleted:    test.txt
    #

Is there a way to do a single command &quot;just delete these files from the repository&quot;?  
Similar to `git add .` which would add all new and modified files to the stage.

I use Visual Studio and Windows explorer to work with my source tree and at some point I just delete a whole bunch of files. I then find it a pain to call `git rm` as the files are no longer around and there is no command line intellisense to help me type it in. 

I just want a command that deletes all files from git that are also deleted from the disk.

How do I commit all deleted files in Git?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/492558/removing-multiple-files-from-a-git-repo-that-have-already-been-deleted-from-disk" target="_blank" rel="noopener noreferrer">Removing multiple files from a Git repo that have already been deleted from disk</a>

If I delete some files from the disk they come up as deleted like so in the Git repo:
<pre><code class="hljs language-makefile">C:\git\bc>git status
# On branch tracking2
# Changed but not updated:
# (use "git add/rm &#x3C;file>..." to update what will be committed)
# (use "git checkout -- &#x3C;file>..." to discard changes in working directory)
#
# deleted: test.txt
#
</code></pre>
Is there a way to do a single command "just delete these files from the repository"? 
Similar to <code>git add .</code> which would add all new and modified files to the stage.
I use Visual Studio and Windows explorer to work with my source tree and at some point I just delete a whole bunch of files. I then find it a pain to call <code>git rm</code> as the files are no longer around and there is no command line intellisense to help me type it in.
I just want a command that deletes all files from git that are also deleted from the disk.

What&#39;s the simplest way to get the most recent tag in Git?

    git tag a HEAD
    git tag b HEAD^^
    git tag c HEAD^
    git tag

output:

    a
    b
    c

Should I write a script to get each tag&#39;s datetime and compare them?

How can I get the latest tag name in current branch in Git?

Take this scenario:

1. I decide to &#39;fork&#39; a codebase on github.com, and start doing my routine: Edit - Commit - Push; aka hack hack hack.
2. After I made some changes, I see some changes another person has made on the same project, and I like them!
3. I decide I want to merge them into mine. Problem is, I only want a &#39;portion&#39; of one particular commit, out of several commits he has made.

What would be the most efficient method of getting these select amount of changes, merged into my &#39;fork&#39;?

Using GIT, how can I selectively merge changes from one commit on another &#39;fork&#39;?

How can you merge two branches in git, retaining *necessary* files from a branch?

When merging two branches, if a file was deleted in one branch and not in another, the file is ultimately deleted.

For example:

 - A file exists in master when you make a new branch
 - you remove the file from master since we don&#39;t need it (yet)
 - you make changes in the branch to add a feature, *which relies on the file existing*
 - *you make bug fixes in master* (cannot be discarded)
 - you merge some day, and the file is gone!

----------


How to Reproduce:

 1. Create a git repo with one file.


        git init
        echo &quot;test&quot; &gt; test.txt
        git add .
        git commit -m &quot;initial commit&quot;


 2. Create a branch

        git branch branchA

 3. Delete the file in master
    
        git rm test.txt
        git commit -m &quot;removed file from master&quot;

 4. Make ANY changes in branchA that don&#39;t touch the deleted file (it has to be unchanged to avoid Conflict)

        git checkout branchA
        touch something.txt
        git add .
        git commit -m &quot;some branch changes&quot;


From here, any way I&#39;ve found to merge these two branches, the test.txt file is deleted.  Assuming we were *relying on the file* for `branchA`, this is a big problem.

----------

**Failing examples:**

Merge 1

    git checkout branchA
    git merge master
    ls test.txt

Merge 2

    git checkout master
    git merge branchA
    ls test.txt
    
Rebase 1

    git checkout branchA
    git rebase master
    ls test.txt

git merge: Removing files I want to keep!

I was reading a blog where the writer said this  

&gt; **&quot;Code doesn’t exist unless it’s checked into a version control system. Use version control for everything you do. Any version control, SVN, Git, even CVS, master it and use it.&quot;**  

I have never used any sort of version control and I do not find it that great. I have googled it and looked at it before, but I just need it put into children&#39;s terms if you will please.  

As I understand it right now, things like SVN are for storing your code online for a group of users or other developers to have access to the same code. Once you update some code, you can submit the new version and the SVN will keep copies of old code as well as the new ones you update.  

Is this the basic idea of it or am I getting it completely wrong?  

If I am right, then it might not be much use if I:

 - Do not have other people working on the code.
 - Do not plan on letting others have the code.


  [1]: http://stackoverflow.com/questions/250984/do-i-really-need-version-control

Why should I use version control?

I have a project on github that I have been working on before.  However, I wiped out my computer and I am wondering which git command should I invoke under my username to checkout my project again so that I can push my latest changes to github under my account.

How do I pull my project from github?

I was assuming that both work in the same way. Both add every file onto index. But I seem wrong.


* What&#39;s the difference between `git add .` and `git add -u`?

What&#39;s the difference between `git add .` and `git add -u`?

I have several .screen files inside `/xxx/documentation` and its subdirectories that are already tracked by Git.

After modifying many of these screen files, I run `git add documentation/\\*.screen`—as indicated by the first example in `git-add`&#39;s documentation—to stage these files, but the command fails:

&lt;pre&gt;fatal: pathspec &#39;documentation/\*.screen&#39; did not match any files&lt;/pre&gt;

Is my command bad, or does git have a bug?

git: How do I recursively add all files in a directory subtree that match a glob pattern?

I&#39;m trying to use `git add --interactive` to selectively add some changes to my index, but I continually receive the &quot;Your edited hunk does not apply. Edit again...&quot; message.  I get this message even if I choose the e option, and immediately save/close my editor.  In other words, without editing the hunk at all, the patch doesn&#39;t apply.

Here&#39;s the exact example I&#39;m using (I&#39;m trying to put together a small demo):

Original file:

    first change
    second change off branch
    third change off branch
    second change
    third change
    fourth change

New file:

    Change supporting feature 1
    first change
    second change off branch
    third change off branch
    second change
    third change
    fourth change
    bug fix 1
    change supporting feature 1

I&#39;m trying to show how to use `git add --interactive` to only add the &quot;bug fix 1&quot; line to the index.  Running interactive add on the file, I choose the patch mode.  It presents me with 

    diff --git a/newfile b/newfile
    index 6d501a3..8b81ae9 100644
    --- a/newfile
    +++ b/newfile
    @@ -1,6 +1,9 @@
    +Change supporting feature 1
     first change
     second change off branch
     third change off branch
     second change
     third change
     fourth change
    +bug fix 1
    +change supporting feature 1

I respond with split, followed by &quot;no&quot; to apply the first hunk.  The second hunk, I try to edit.  I originally tried deleting the bottom line - that didn&#39;t work.  Leaving the hunk alone completely doesn&#39;t work either, and I can&#39;t figure out why.

git add --interactive &quot;Your edited hunk does not apply&quot;

Is there a way to add all files no matter what you do to them whether it be deleted, untracked, etc? like for a commit. I just don&#39;t want to have to `git add` or `git rm` all my files every time I commit, especially when I&#39;m working on a large product.

Git add all files modified, deleted, and untracked?

What&#39;s the difference between:

- `git add .`
- `git commit -a`

Should I be doing both, or is that redundant?

How do I commit all deleted files in Git?

Git Problem Overview

Git Solutions

How do I avoid capturing self in blocks when implementing an API?

Swift Beta performance: sorting arrays

Attributions