sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: opencv
Issue: UMat tests hang on Odroid
Labels: bug,priority: low,category: ocl,category: t-api

On an Ondroid XU4 board using OpenCL via T-API causes the function to never return, the program has to be stopped with Ctrl+C. The behavior is reproduced in the unit tests: if I run `bin/opencv_test_core --gtest_filter=UMat.*`, it gets stuck in `UMat.unmap_in_class` after printing "leave ProcessData()". I found that it only happens if the test is executed after `UMat.async_unmap`. Other tests that get stuck after it are `map_unmap_counting, mat_umat_sync, testTempObjects_Mat, testTempObjects_UMat, testWrongLifetime_Mat, testWrongLifetime_UMat`. The following tests from UMat.\* _don't_ get stuck: `BufferPoolGrowing, CopyToIfDeviceCopyIsObsolete, ReadBufferRect, setOpenCL, Sync, synchronization_map_unmap, SyncTemp`.
The OpenCL API from OpenCV 2.4 works without this problem.

The device is running under Ubuntu 15.04, GCC 4.9.2, this is what's printed before the test runs:

```
CTEST_FULL_OUTPUT
OpenCV version: 3.1.0
OpenCV VCS version: unknown
Build type: release
Parallel framework: tbb
CPU features: 
OpenCL Platforms: 
    ARM Platform
        iGPU: Mali-T628 (OpenCL 1.1 )
        iGPU: Mali-T628 (OpenCL 1.1 )
Current OpenCL device: 
    Type = iGPU
    Name = Mali-T628
    Version = OpenCL 1.1 
    Compute units = 4
    Max work group size = 256
    Local memory size = 32 kB 
    Max memory allocation size = 497 MB 646 kB 
    Double support = Yes
    Host unified memory = Yes
    Has AMD Blas = No
    Has AMD Fft = No
    Preferred vector width char = 16
    Preferred vector width short = 8
    Preferred vector width int = 4
    Preferred vector width long = 2
    Preferred vector width float = 4
    Preferred vector width double = 2
```
Repository: opencv
Issue: Exception when using CUDA APIs after resume from suspension
Labels: bug,category: gpu/cuda (contrib)

With the curent OpenCV on the repository, an error occurs if the laptop is suspended and then resumed while a program using OpenCV is running. This error appears to happen when using CUDA APIs, and specifically in my case happens with the matcher in features2d module. Note that it doesn't happen when using the corresponding CPU function.

Possibly this it not necessarily a bug of OpenCV, but could be related with the suspension manager.

Below some more details about the configuration and error:

**system**
_OS: Ubuntu 14.04.4
OpenCV: from GitHub master fork (i.e., 3.1.0), SHA: 81f21e6e6cec209bffeab77934e5f4fad9cc1c23
built with the following flags_
`cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON -D ENABLE_FAST_MATH=1 -D CUDA_FAST_MATH=1 -D WITH_CUBLAS=1`

_Compiler: g++ 4.8.4-2ubuntu1~14.04.1
CUDA: 7.5_

**error thrown**

_OpenCV Error: Gpu API call (an illegal instruction was encountered) in call, file /home/alberto/lib/opencv/modules/cudev/include/opencv2/cudev/grid/detail/transform.hpp, line 273
terminate called after throwing an instance of 'cv::Exception'
  what():  /home/alberto/lib/opencv/modules/cudev/include/opencv2/cudev/grid/detail/transform.hpp:273: error: (-217) an illegal instruction was encountered in function call_
Repository: opencv
Issue: Linux build instructions, ffmpeg or libav
Labels: feature,category: documentation

I would like to add to the linux install instructions the option to use ffmpeg instead of libav packages.
I am new to all of this, so please help me avoid doing something the wrong way.
I have my suggested changes to the corresponding doc file already in a forked repo, should I create a pull request?
Repository: youtube-dl
Issue: No keep audio option? (Target resault: video+audio file, audio only file)
Labels: request

At the moment, the "--keep-video" option saves both the video and audio files after they've been merged.
I would like the ability to save just the audio file with the merged file, producing the followings files:

Video+Audio (Merged) file
Audio file

Or am I blind and have missed the option somewhere?
Repository: TypeScript
Issue: Allow subclass constructors without super() call
Labels: Suggestion,Needs Proposal

**TypeScript Version:** 

1.8.0

**Code**

Custom element classes often have constructors that just return `document.createElement()`, since HTMLElement doesn't have a callable constructor, but this generates an error in TypeScript:

``` ts
class MyElement extends HTMLElement {
  constructor() {
    return document.createElement('my-element');
  }
}
```

In general, it is completely valid ES2015 to not call `super()`, as long as you don't access `this`.
Repository: go
Issue: spec: clarification for the language used in the language specifications
Labels: Documentation,NeedsInvestigation

Hi,

I'm not a native English speaker so please bare with me.

While looking at the documentation for https://golang.org/ref/spec#Integer_overflow I've realized that the sentence: `Loosely speaking, these unsigned integer operations discard high bits upon overflow, and programs may rely on "wrap around".` currently leaves room for interpretation.

I can read this as: for now one can assume the `wrap around` will happen but it might be changed in the future. Or I can read this as `wrap around` will always be present (in Go 1.x).

Then based on the discussion I've had on this topic, I've realized that there are other points as well in the language specifications which are ambiguous. For example `Implementation restriction: For compatibility with other tools, a compiler may disallow the NUL character (U+0000) in the source text.` sounds awful when you think of a limitation, `Implementation restriction`, and a `may`, optional, are involved. I've interpreted that as `[..] must disallow [..]` only because the sentence starts with `Implementation restriction` but someone else said `may` is not necessarily equivalent to `must` (and I can understand where that version comes from).

As there are 144 `may`s in the document, I think that some better description of what `may` or `must` or `may not`, in the same style that IETF RFCs always define what `must`, `must not`, `may` and so on represent. This would also help people that are used to RFCs but are not necessarily native English speakers. It would also people that write compilers, static analysis tools and end-users.

Thank you for your consideration.
Repository: go
Issue: cmd/compile: coverage instrumentation for fuzzing
Labels: NeedsFix,FeatureRequest,compiler/runtime

Go-fuzz (https://github.com/dvyukov/go-fuzz) is quite successful at finding bugs in Go code and reasonably widely used in Go community. However there are several problems with the current go-fuzz implementation that hinder wider adoption (in particular internal adoption at Google):
1. go-fuzz mimics go tool build logic, which leads to constant breakages.
2. go-fuzz-build does not handle cgo, and it is hard to implement.
3. coverage instrumentation is source-to-source, which makes it very difficult to integrate with other build systems.
4. source-to-source transformation can't handle all cases and has limited transformation capabilities (e.g. instrumenting && is tough). Some code patterns can be mishandled or lead to build failures.
5. source-to-source transformation produces slow code (lots of closures).

Ideally we have coverage instrumentation in compiler, and corresponding support in go tool. Something similar to -race flag, which triggers compiler instrumentation and adds race build tag.
Repository: vscode
Issue: Get selected file/folder in the explorer view
Labels: feature-request,api,file-explorer

It would be nice if it was possible to retrieve the selected file/folder in the explorer view. The use case where I want to use it for is my `vscode-yo` extension to be able to run the generator in the selected directory. An API for this would be nice.
Repository: neovim
Issue: Consider removing netrw in favor of dirvish
Labels: runtime

Netrw is not bad but it shouldn't be the default file manager for this reasons:
- adds over 300 tags to help file
- has no sane method of updating when bundled by default (realistically an over 10 000 line plugin should be updateable easily)
- needs some additional plugins to behave reasonably (like vim-vinegar)
- has some (long standing) bugs
- no fresh github mirror for use with plugin managers
- slows down startup

On the plus side of netrw:
- very comprehensive file manager
- has insane nearly 4000 lines documentation file (although intimidating for most i think)

Dirvish:
- is lean
- not buggy
- does most commonly used features netrw + vinegar ootb

On minus sides:
- hooks into netrw commands? ie. doesnt offer its own :H and :Vexplore, etc if netrw isnt installed, although you can use `:e .` or `:sp .` etc.
- doesn't offer gx command

Afaik from my grepping it seems that the only thing that depends on this plugin is some spellchecking in `spell-SpellFileMissing`.

In the same vein vimball plugin should be dropped. From my testing after removing netrw on vanilla vim and cleaning help tags i can't see any breakage.
Repository: kubernetes
Issue: Preemption priority / scheme
Labels: priority/important-soon,area/api,sig/scheduling,sig/node,kind/feature,milestone/removed,lifecycle/frozen

We expect Kubelet to make more and more decision on which pods should run on a given node. For example,
- Reject pods on port conflict
- Reject incoming / evict existing pods when node constraints are violated. 
- Reject incoming / evict existing pods in response to resource starvation, such as OOD, OOM, etc. (#147, #18724)
- ... 

To really do that, Kubelet needs to know preemption priority / scheme, so that Kubelet knows which one(s) should be evicted, so that the most important pods run when resource demand exceeds supply. For example, daemonset pods should have higher priority than rest of pods, and kube-system pods might have a relatively higher priority too. 

cc/ @bgrant0607 @davidopp
Repository: thefuck
Issue: Change way of interaction with shells
Labels: help wanted

I guess it would be nice to:
- put shell aliases in environment variable (`TF_SHELL_ALIASES`) in alias and get it from there, instead of calling shell from app (done for bash and zsh);
- move all writes to history to alias (done for bash and zsh).

It would speedup thefuck, and probably will fix #428, #422 and #402.
Repository: rust
Issue: It should be possible to override the dsymutil path
Labels: A-frontend,C-feature-request

The compiler currently invokes `dsymutil` directly, but a cross compilation toolchain may have it located under a different name like `x86_64-apple-darwin15-dsymutil`. There should be a compiler flag to override it like there is for the linker.
Repository: You-Dont-Know-JS
Issue: "types & grammar": Pre-ES6 Number.isSafeInteger(..) polyfill - Number.MAX_SAFE_INTEGER is also introduced ES6
Labels: for second edition

In Chapter 2 of "types & grammar", the following polyfill is prescribed for `Number.isSafeInteger(..)`

> To polyfill Number.isSafeInteger(..) in pre-ES6 browsers:
> 
> ```
> if (!Number.isSafeInteger) {
>     Number.isSafeInteger = function(num) {
>         return Number.isInteger( num ) &&
>             Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
>     };
> }
> ```

Unless I'm mistaken, isn't Number.MAX_SAFE_INTEGER also an ES6 feature? Perhaps the code should rather be:

```
if (!Number.isSafeInteger) {
    Number.isSafeInteger = function(num) {
        return Number.isInteger( num ) &&
            Math.abs( num ) <= (Math.pow( 2, 53 ) - 1)
    };
}
```
Repository: TypeScript
Issue: allow decorators for functions
Labels: Suggestion,Domain: Decorators,Waiting for TC39

did a quick search, it looks like this hasn't been yet requested

currently decorators can only be added to classes, methods and properties

consider allowing them on functions too
Repository: youtube-dl
Issue: Support setproctitle on Mac OS X [was: Question: Any way for a shell script to check if youtube-dl is running?]
Labels: request

Hello, I've created an Applescript for personal use that works as a sort of wrapper around youtube-dl so I can download multiple videos quickly. I'm trying to modify it so that it won't download multiple videos at the same time.

In order to accomplish this, I need to check to see if the youtube-dl process is already running (and if so, wait until it finishes. I'm currently accomplishing this with the following shell script:
`ps -ax -o etime,command -c | grep python`
Which will return the empty string if python is not running. Since youtube-dl uses python, this can be used to approximate whether youtube-dl itself is running.

Of course, however, this causes problems if I run a program other than youtube-dl which depends on Python. Is there any way to check if youtube-dl itself is currently running? Thank you so much!
Repository: neovim
Issue: Softwrap at arbitrary boundary
Labels: enhancement,complexity:high,core

- Neovim version: 0.1.2
- Operating system: Arch Linux
- Terminal emulator: Gnome Terminal
### Actual behaviour

Vim `:set wrap` has always soft-wrapped at the window border. Neovim follows this behavior
### Expected behaviour

I would be able to like to have a `:set wrapwidth=80` and have Neovim softwrap at the 80th column, even if the window is 120 characters wide.
### Steps to reproduce
1. `:set wrap`
2. Type a lot
3. Resize window (the wrap follows the window)

If this could be implemented I'd greatly appreciate it. I've found [this](https://stackoverflow.com/questions/989093/soft-wrap-at-80-characters-in-vim-in-window-of-arbitrary-width) stack overflow question about it but haven't found a solution that works when I have multiple windows open. If it were built into Neovim I think it would be nice.

A way to implement this would be an internal border feature where users could set an internal border for a window. If they could set the internal border such that the window is always 80 characters wide it would achieve the same thing. In my eyes this would work similarly to the Goyo plugin but instead of having a border around the whole view, each window could have it's own local border.

If I'm missing anything let me know. I've been looking to do this or a while but haven't found a way.
Repository: flutter
Issue: Redirect "dart:io" stderr and stdout to adb (Android) and syslog (iOS)
Labels: c: new feature,platform-android,platform-ios,framework,engine,dependency: dart,has reproducible steps,P3,dependency: dart:io,team-engine,triaged-engine,found in release: 3.16,found in release: 3.18

Today we only redirect `print` (see https://github.com/flutter/engine/blob/master/sky/engine/bindings/dart_runtime_hooks.cc). We should also do this for stderr and stdout.
### Steps to Reproduce
- In your app `import 'dart:io';`
- Do `stdout.writeln('message')` or `stderr.writeln('message')`
- Run `flutter logs`
- Run your app using `flutter start` or run a test using `flutter drive`
- Observe that logs do not show any output
### Flutter Version

https://github.com/flutter/flutter/commit/7ee1ee31d16c3bcf0fcefbac283bfb50594b949f

/cc @johnmccutchan
Repository: go
Issue: cmd/compile: SSA, don't re-copy spilled output parameters
Labels: Performance,compiler/runtime

``` go
func f(a []int) (s int) {
    for _, x := range a {
        s += x
    }
    runtime.GC()
    return
}
```

The SSA-generated code does this after runtime.GC():

```
        MOVQ    "".s+32(FP), BX
        MOVQ    BX, "".s+32(FP)
```

We should teach the compiler that it doesn't need to move the result to the output slot if was already spilled to the correct slot.
Repository: rust
Issue: Surprising lifetime inference with closures
Labels: A-lifetimes,A-closures,T-compiler,C-bug,D-confusing

The following code fails to compile due to a lifetime error: the intent is for the closure to mutably borrow the variable only until it returns, but somehow the lifetime of the borrow gets inferred to last as long as the variable itself.

``` rust
fn main() {
    let func = |a| { a; };
  //let func = |a: &mut u32| { a; };
  //let func = |a| { };
    let mut what: u32 = 2;
    loop {
        func(&mut what);
    }
}
```

```
a.rs:7:19: 7:23 error: `what` does not live long enough
a.rs:7         func(&mut what);
                         ^~~~
a.rs:2:27: 9:2 note: reference must be valid for the block suffix following statement 0 at 2:26...
a.rs:2     let func = |a| { a; };
a.rs:3   //let func = |a| { };
a.rs:4   //let func = |a: &mut u32| { a; };
a.rs:5     let mut what: u32 = 2;
a.rs:6     loop {
a.rs:7         func(&mut what);
       ...
a.rs:5:27: 9:2 note: ...but borrowed value is only valid for the block suffix following statement 1 at 5:26
a.rs:5     let mut what: u32 = 2;
a.rs:6     loop {
a.rs:7         func(&mut what);
a.rs:8     }
a.rs:9 }
```

Either of the commented alternatives makes compilation succeed.  The first, making the lifetime signature (semi-)explicit, makes sense; it's odd that simply removing a useless reference to the variable also works, though.

Anyway, while I don't know how the lifetime inference algorithm works, and in particular I don't know whether improving the situation could impact backwards compatibility, it's surprising to me that it can't figure out a reasonable lifetime in this case.
Repository: go
Issue: runtime: let idle OS threads exit
Labels: NeedsDecision

1. What version of Go are you using (`go version`)?
   1.5.3, 1.6
2. What operating system and processor architecture are you using (`go env`)?
   x86_64 - OSX and Linux
3. What did you do?
   Any golang program will create a new OS thread when it needs to if things are blocked. But these threads aren't ever destroyed. For example, a program using 7 goroutines might have 40+ OS threads hanging around. The numbers will surely get much higher as traffic fluctuates against a golang server process throughout the day.
4. What did you expect to see?
   Once an OS thread has been idle long enough, I would have expected it to be destroyed. Being recreated if needed. Expanding and contracting like the relationship between the heap and GC.
5. What did you see instead?
   The many OS threads that were created hang around even with an idle program and very few goroutines.

---

After doing some reading into other (closed) issues on this repo dating back to 2012 - including the one where `SetMaxThreads` was introduced - I'm curious, why keep the OS threads around instead of cleaning them up?
Repository: rust
Issue: fn pointer coercion fails for method on type with lifetime
Labels: A-lifetimes,C-bug

The following code does not infer the type of the method correctly:

``` rust
/*
<anon>:12:31: 12:45 error: mismatched types:
 expected `fn(MyStruct<'_>)`,
    found `fn(MyStruct<'_>) {MyStruct<'a>::func}`
(expected concrete lifetime,
    found bound lifetime parameter ) [E0308]
<anon>:12     let fails: fn(MyStruct) = MyStruct::func; // ERROR: mismatched types
                                        ^~~~~~~~~~~~~~
<anon>:12:31: 12:45 help: see the detailed explanation for E0308
*/
struct MyStruct<'a> {
    y: &'a u32,
}

impl<'a> MyStruct<'a> {
    pub fn func(self) {}
}

fn wrapper<'a>(x: MyStruct<'a>) { x.func() }

fn main() {
    let fails: fn(MyStruct) = MyStruct::func; // ERROR: mismatched types
    let works: fn(MyStruct) = wrapper;
}
```

As one can see in the error message (**found `fn(MyStruct<'_>) {MyStruct<'a>::func}`**), it seems that the compiler is getting confused when inferring the type of the expression. 

If the lifetime from MyStruct is removed, the code compiles fine. 

**PS:**
Thanks to `huon` for simplifying the example demonstrating the issue
Repository: java-design-patterns
Issue: Collector State Pattern
Labels: epic: pattern,type: feature

**Description:**
The Collector State design pattern is a behavioral design pattern used in real-time software to manage scenarios where a sequence of messages needs to be collected before initiating further actions. Key elements include:

- **Collected Message Handler:** Receives and processes messages, starts and stops timers, and decides when the collection is complete.
- **Timeout Handler:** Manages timeout events, determining the status of the collection (success or failure).

This pattern is particularly useful in situations like digit collection for call routing, where messages are collected and processed based on specific conditions and timeouts.

**References:**
- [Collector State Pattern](https://www.eventhelix.com/design-patterns/collector-state/)
- [Java Design Patterns Contribution Guidelines](https://github.com/iluwatar/java-design-patterns/wiki)

**Acceptance Criteria:**
1. Implement the basic structure of the Collector State design pattern, including the Collected Message Handler and Timeout Handler.
2. Provide a working example demonstrating the usage of the Collector State pattern with unit tests to ensure functionality.
3. Ensure the implementation adheres to the project's contribution guidelines as outlined in the [java-design-patterns wiki](https://github.com/iluwatar/java-design-patterns/wiki).
Repository: thefuck
Issue: psutil: platform cygwin is not supported (thefuck won't install on Cygwin)
Labels: windows

Hi, I'm on Cygwin trying to install `thefuck`, but I get the following output when running `pip install thefuck`:

```
[project (master)] pip install thefuck
You are using pip version 6.1.1, however version 8.0.3 is available.
You should consider upgrading via the 'pip install --upgrade pip' command.
Collecting thefuck
  Using cached thefuck-3.3-py2.py3-none-any.whl
Collecting psutil (from thefuck)
  Using cached psutil-4.0.0.tar.gz
    Complete output from command python setup.py egg_info:
    platform cygwin is not supported
```

Do you have any idea how I could fix this? I'm willing to work on this myself but I'm not sure where I should start. Any help would be greatly appreciated.

EDIT: I also tried installing it using `pip3` but it gave the same error. Any have experience on getting `thefuck` running on the latest 64-bits Cygwin?
Repository: TypeScript
Issue: Decorators not allowed classes expressions
Labels: Suggestion,Domain: Decorators,Waiting for TC39

Not sure if this is by design or not, but the following gives a compile error of "Decorators are not valid here" with TypeScript 1.8:

``` ts
let testClass = new class {
    testMethod(@myDecorator date: Date): any {
        return date;
    }
}();
```
Repository: kubernetes
Issue: Facilitate ConfigMap rollouts / management
Labels: priority/backlog,area/app-lifecycle,sig/apps,sig/service-catalog,area/configmap-api,area/declarative-configuration,lifecycle/frozen

To do a rolling update of a ConfigMap, the user needs to create a new ConfigMap, update a Deployment to refer to it, and delete the old ConfigMap once no pods are using it. This is similar to the orchestration Deployment does for ReplicaSets.

One solution could be to add a ConfigMap template to Deployment and do the management there.

Another could be to support garbage collection of unused ConfigMaps, which is the hard part. That would be useful for Secrets and maybe other objects, also.

cc @kubernetes/sig-apps-feature-requests