internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: acl-org/acl-anthology

Issue:
Reingestion Request: ROCLING (10-20-2023)
### General information about this request

- [X] I confirm that I have read the [Information for Submitters](https://aclanthology.org/info/contrib/).
- [ ] I am submitting a request for a **new venue** that does not exist in the ACL Anthology yet.

### Venue Identifier

ROCLING

### Volume Title

Proceedings of the 35th Conference on Computational Linguistics and Speech Processing (ROCLING 2023)

### Venue Name (only if you are submitting a new venue)

Conference on Computational Linguistics and Speech Processing

### Venue Website (only if you are submitting a new venue)

https://rocling2023.github.io/

### Date of Publication

2023-10-20

### Supporting Information

Dear Anthology Director,

I'm Hou-Chiang Tseng who the publication chair of the 35th annual Conference on Computational Linguistics and Speech Processing (ROCLING 2023).

The conference website: https://rocling2023.github.io/

We want to register the ROCLING 2023 to ACL Anthology. Please see following two items:
(a) the complete list of volumes: please see the attached file,
and (b) all the new material can be downloaded from the following URL:
https://drive.google.com/drive/folders/1dxt_gYlUvmuLiNETgDRg9cGpiJxVGwbD?usp=sharing

If there is any question, please let me know.
[Anthology.Volume_ROCLING.2023.xlsx](https://github.com/acl-org/acl-anthology/files/14318157/Anthology.Volume_ROCLING.2023.xlsx)

Best regards,
Dr. Hou-Chiang Tseng


Discussion:
@ouartz99 Rocling 2023 has been ingested: https://aclanthology.org/volumes/2023.rocling-1/ Is there a reason for re-ingestion? 
@anthology-assist 

After the discussion here: https://github.com/acl-org/acl-anthology/issues/2994#issuecomment-1934764637

mjpost and anthology-assist have informed me that I need to reingestion.

So I have prepared all the data and am proceeding with this re-ingestion.

I'm not sure if my current approach is correct; can you help me?

Thank you very much.
@ouartz99 got it, thank you! I will re-ingest shortly.

Resolving patch:
diff --git a/bin/volumes_from_diff.py b/bin/volumes_from_diff.py
--- a/bin/volumes_from_diff.py
+++ b/bin/volumes_from_diff.py
@@ -20,6 +20,7 @@
 
 volumes = []
 for filepath in sys.stdin:
+    filepath = filepath.rstrip()
     if filepath.startswith("python/") or not filepath.endswith(".xml"):
         continue
 


Test patch:
Repository: google-deepmind/optax

Issue:
Implement gradient centralisation
See paper

https://arxiv.org/abs/2004.01461

This transform is fairly easy to implement.


Discussion:
I would like to implement this issue!
Great! Looking forward to your contribution!

Resolving patch:
diff --git a/optax/__init__.py b/optax/__init__.py
--- a/optax/__init__.py
+++ b/optax/__init__.py
@@ -43,6 +43,7 @@
 from optax._src.transform import AddNoiseState
 from optax._src.transform import apply_every
 from optax._src.transform import ApplyEvery
+from optax._src.transform import centralize
 from optax._src.transform import clip
 from optax._src.transform import clip_by_global_norm
 from optax._src.transform import ClipByGlobalNormState
@@ -93,6 +94,7 @@
     "apply_updates",
     "ApplyEvery",
     "ApplyIfFiniteState",
+    "centralize",
     "chain",
     "clip",
     "clip_by_global_norm",
diff --git a/optax/_src/transform.py b/optax/_src/transform.py
--- a/optax/_src/transform.py
+++ b/optax/_src/transform.py
@@ -605,3 +605,35 @@ def update_fn(updates, state, params=None):
     return updates, ApplyEvery(count=count_inc % k, grad_acc=grad_acc)
 
   return GradientTransformation(init_fn, update_fn)
+
+
+def _subtract_mean(g):
+  if len(g.shape) > 1:
+    return g - g.mean(tuple(range(1, len(g.shape))), keepdims=True)
+  else:
+    return g
+
+
+class CentralState(OptState):
+  """The `centralize` transformation is stateless."""
+
+
+def centralize() -> GradientTransformation:
+  """Centralize gradients.
+
+  References:
+    [Yong et al, 2020](https://arxiv.org/abs/2004.01461)
+
+  Returns:
+    An (init_fn, update_fn) tuple.
+  """
+
+  def init_fn(_):
+    return CentralState()
+
+  def update_fn(updates, state, params=None):
+    del params
+    updates = jax.tree_map(_subtract_mean, updates)
+    return updates, state
+
+  return GradientTransformation(init_fn, update_fn)


Test patch:
diff --git a/optax/_src/transform_test.py b/optax/_src/transform_test.py
--- a/optax/_src/transform_test.py
+++ b/optax/_src/transform_test.py
@@ -154,6 +154,18 @@ def test_clip_by_global_norm(self):
       # Check that continuously clipping won't cause numerical issues.
       chex.assert_tree_all_close(updates, updates_step, atol=1e-7, rtol=1e-7)
 
+  @parameterized.named_parameters([
+      ('1d', [1.0, 2.0], [1.0, 2.0]),
+      ('2d', [[1.0, 2.0], [3.0, 4.0]], [[-0.5000, 0.5000], [-0.5000, 0.5000]]),
+      ('3d', [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]]],
+        [[[-1.5000, -0.5000], [0.5000, 1.5000]], [[-1.5000, -0.5000], [0.5000, 1.5000]]]),
+  ])
+  def test_centralize(self, inputs, outputs):
+    inputs = jnp.asarray(inputs)
+    outputs = jnp.asarray(outputs)
+    centralizer = transform.centralize()
+    centralized_inputs, _ = centralizer.update(inputs, None)
+    chex.assert_tree_all_close(centralized_inputs, outputs)
 
 if __name__ == '__main__':
   absltest.main()
Repository: google-deepmind/optax

Issue:
Prevent creating unnecessary momentum variables
Currently, `optax.sgd` and `optax.noisy_sgd` unconditionally create momentum variables for the parameters, since both rely on `trace`. For `optax.noisy_sgd`, this is unnecessary since `decay` is always `0`. For `optax.sgd`, this is unexpected since `momentum=0` by default (and can be wasteful for large models). 

`optax.noisy_sgd` should only require `_scale_by_learning_rate` (with a negation). `optax.sgd` could conditionally add `trace` if `momentum > 0`. 

Below are the lines of code I'm referring to:

https://github.com/deepmind/optax/blob/ba0bc11d172054d65b4387ecae840c04e2bc7035/optax/_src/alias.py#L142-L148

https://github.com/deepmind/optax/blob/ba0bc11d172054d65b4387ecae840c04e2bc7035/optax/_src/alias.py#L105-L113

And here's where trace automatically creates it's state:

https://github.com/deepmind/optax/blob/ba0bc11d172054d65b4387ecae840c04e2bc7035/optax/_src/transform.py#L212-L213


Discussion:
Good point!

Yeah `optax.noisy_sgd` should just be
```
def noisy_sgd(learning_rate: ScalarOrSchedule, 
               eta: float = 0.01, 
               gamma: float = 0.55, 
               seed: int = 0) -> GradientTransformation: 
   return combine.chain( 
       _scale_by_learning_rate(learning_rate), 
       transform.add_noise(eta, gamma, seed), 
   ) 
```
And you are right for `optax.sgd` we could check whether momentum > 0 and skip the trace when this is not the case
Do you want to put together a PR?
Sure! 

Resolving patch:
diff --git a/optax/_src/alias.py b/optax/_src/alias.py
--- a/optax/_src/alias.py
+++ b/optax/_src/alias.py
@@ -15,7 +15,7 @@
 # ==============================================================================
 """Aliases for popular optimisers."""
 
-from typing import Union
+from typing import Union, Optional
 
 import jax.numpy as jnp
 from optax._src import combine
@@ -107,7 +107,6 @@ def noisy_sgd(learning_rate: ScalarOrSchedule,
               gamma: float = 0.55,
               seed: int = 0) -> GradientTransformation:
   return combine.chain(
-      transform.trace(decay=0., nesterov=False),
       _scale_by_learning_rate(learning_rate),
       transform.add_noise(eta, gamma, seed),
   )
@@ -140,11 +139,12 @@ def rmsprop(learning_rate: ScalarOrSchedule,
 
 
 def sgd(learning_rate: ScalarOrSchedule,
-        momentum: float = 0.,
+        momentum: Optional[float] = None,
         nesterov: bool = False) -> GradientTransformation:
   return combine.chain(
-      transform.trace(decay=momentum, nesterov=nesterov),
-      _scale_by_learning_rate(learning_rate),
+      (transform.trace(decay=momentum, nesterov=nesterov)
+       if momentum is not None else transform.identity()),
+      _scale_by_learning_rate(learning_rate)
   )
 
 


Test patch:
Repository: pytorch/torchdynamo

Issue:
Which IPEX version is supported as the backend
I think the latest IPEX has no method of `_optimize_catch_errors` , may I kindly know which IPEX version is supported as the default `ipex` optimization backend? https://github.com/facebookresearch/torchdynamo/blob/476ca6b7c148dd6705bf218684dfe05c6cd9fcfb/torchdynamo/optimizations/backends.py#L281-L285



Discussion:
cc @jiayisunx @jgong5
The latest commit at the time of my testing was:
```
commit 7e679d05c938358d78988407d1458c9d9af8b9ff
Author: jiayisunx <jiayi.sun@intel.com>
Date:   Fri Oct 29 12:42:23 2021 +0800

    remove AdaptiveMaxPool2d and AvgPool2d from blacklist (#270)
    
    * remove AdaptiveMaxPool2d and AvgPool2d from blacklist
    
    * set upsample as FallThrough in autocast
    
    Co-authored-by: Wang Weihan <eikan.wang@intel.com>
```

I haven't tested this backend since then, so it is possible things have changed upstream since then.

PRs to fix this are welcome!

Thanks for the quick comment @jansel. From the code snip below
https://github.com/facebookresearch/torchdynamo/blob/476ca6b7c148dd6705bf218684dfe05c6cd9fcfb/torchdynamo/optimizations/backends.py#L281-L285
I think `_optimize_catch_errors` should be a method of `ipex`, but I don't think ipex provides this kind of method (even with the commit you provide: 7e679d05c938358d78988407d1458c9d9af8b9ff).
Does `torchdynamo` have done some magic thing to provide this method of ipex?



Ah, I think you found a bug.  `ipex._optimize_catch_errors()` should be replaced with `ipex.optimize()`

I introduced the bug with [this commit](https://github.com/facebookresearch/torchdynamo/commit/54d8ff279e9074583c097f55a9b92810742938be) where I renamed `torchdynamo.eval_frame.optimize()` to `torchdynamo.eval_frame._optimize_catch_errors()`.  The automated search-and-replace I did to do that update caught `ipex.optimize()` as a false positive.

Sorry about that!

Thanks for the confirm @jansel.

Resolving patch:
diff --git a/torchdynamo/optimizations/backends.py b/torchdynamo/optimizations/backends.py
--- a/torchdynamo/optimizations/backends.py
+++ b/torchdynamo/optimizations/backends.py
@@ -282,7 +282,7 @@ def taso(subgraph):
 def ipex(subgraph):
     import intel_extension_for_pytorch
 
-    return intel_extension_for_pytorch._optimize_catch_errors(subgraph.scripted)
+    return intel_extension_for_pytorch.optimize(subgraph.scripted)
 
 
 def _raise_timeout(signum, frame):


Test patch:
Repository: pytorch/torchdynamo

Issue:
./torchbench.py -dcuda --inductor -k BERT_pytorch failing 
Asked for repro, got logs from Bin: https://gist.github.com/voznesenskym/ee1c4339f54683da71f49faaa875502b (cc: @desertfire)



Discussion:

Resolving patch:
diff --git a/torchinductor/ir.py b/torchinductor/ir.py
--- a/torchinductor/ir.py
+++ b/torchinductor/ir.py
@@ -298,6 +298,12 @@ def fn(index):
             )
         )
 
+    @staticmethod
+    def default_value(reduction_type, dtype):
+        return {"sum": 0, "max": float("-inf"), "min": float("inf"), "any": 0}[
+            reduction_type
+        ]
+
 
 def is_storage_and_layout(x):
     try:


Test patch:
Repository: pytorch/torchdynamo

Issue:
Dynamo WONT CONVERT for is_fx_tracing()
Probably the same as #1009. Repro:
```
import torchdynamo
from torch.fx._symbolic_trace import is_fx_tracing

def my_compiler(gm, inputs):
    return gm.forward

@torchdynamo.optimize(my_compiler)
def fn(x, y):
    if is_fx_tracing():
        return x
    else:
        return y

fn(1, 2)
```
returns
```
torchdynamo.convert_frame: [ERROR] WON'T CONVERT fn /private/home/suo/scratch/test.py line 8
due to:
Traceback (most recent call last):
  File "/raid/suo/torchdynamo/torchdynamo/variables/tensor.py", line 258, in create
    assert (
AssertionError: torch.* op returned non-Tensor bool call_function <function is_fx_tracing at 0x7f08b681e700>

from user code:
   File "/private/home/suo/scratch/test.py", line 10, in fn
    if is_fx_tracing():

Set torchdynamo.config.verbose=True for more information
==========
```


Discussion:

Resolving patch:
diff --git a/torchdynamo/config.py b/torchdynamo/config.py
--- a/torchdynamo/config.py
+++ b/torchdynamo/config.py
@@ -46,6 +46,8 @@ class AccessLimitingConfig(ModuleType):
         torch.jit.is_scripting: False,
         torch.jit.is_tracing: False,
         torch._C._get_tracing_state: None,
+        torch.fx._symbolic_trace.is_fx_tracing: False,
+        torch.onnx.is_in_onnx_export: False,
     }
 
     # root folder of the project


Test patch:
diff --git a/test/test_functions.py b/test/test_functions.py
--- a/test/test_functions.py
+++ b/test/test_functions.py
@@ -152,6 +152,20 @@ def test_tuple2(a, b):
         args = [a, b]
         return sub(*args)
 
+    @make_test
+    def test_is_in_onnx_export(x, y):
+        if torch.onnx.is_in_onnx_export():
+            return x - 1
+        else:
+            return y + 1
+
+    @make_test
+    def test_is_fx_tracing(x, y):
+        if torch.fx._symbolic_trace.is_fx_tracing():
+            return x - 1
+        else:
+            return y + 1
+
     @make_test
     def test_listarg1(a, b):
         return torch.cat([a, b])
Repository: pytorch/torchdynamo

Issue:
debug saving pre- and post-fusion IR doesn't work
Running repro in #1178 with TORCHINDUCTOR_TRACE=1 results in 
```
  File "/scratch/ngimel/work/repos/torchdynamo/torchinductor/debug.py", line 304, in ir_post_fusion
    self._write_ir("ir_post_fusion.txt", nodes)
  File "/scratch/ngimel/work/repos/torchdynamo/torchinductor/debug.py", line 309, in _write_ir
    fd.write(node.debug_str())
  File "/scratch/ngimel/work/repos/torchdynamo/torchinductor/scheduler.py", line 83, in debug_str
    f"{name}.met_dependencies = {pformat(self.read_writes.reads - self.unmet_dependencies)}",
  File "/scratch/ngimel/work/repos/torchdynamo/torchinductor/scheduler.py", line 38, in pformat
    result = pprint.pformat(obj, indent=4)
  File "/scratch/ngimel/work/env/lib/python3.9/pprint.py", line 58, in pformat
    return PrettyPrinter(indent=indent, width=width, depth=depth,
  File "/scratch/ngimel/work/env/lib/python3.9/pprint.py", line 153, in pformat
    self._format(object, sio, 0, 0, {}, 0)
  File "/scratch/ngimel/work/env/lib/python3.9/pprint.py", line 176, in _format
    p(self, object, stream, indent, allowance, context, level + 1)
  File "/scratch/ngimel/work/env/lib/python3.9/pprint.py", line 248, in _pprint_set
    object = sorted(object, key=_safe_key)
  File "/scratch/ngimel/work/env/lib/python3.9/site-packages/sympy/core/relational.py", line 511, in __bool__
    raise TypeError("cannot determine truth value of Relational")
TypeError: cannot determine truth value of Relational
```
(similar for pre_fusion)


Discussion:
I saw this on my divide-by-zero PR in lowering.py (See my comment with that same typerror string in the file), I can take this on if you don't have time @ngimel. 

Resolving patch:
diff --git a/torchinductor/scheduler.py b/torchinductor/scheduler.py
--- a/torchinductor/scheduler.py
+++ b/torchinductor/scheduler.py
@@ -35,6 +35,9 @@
 
 
 def pformat(obj):
+    if isinstance(obj, set):
+        # pformat has trouble with sets of sympy exprs
+        obj = sorted(obj, key=str)
     result = pprint.pformat(obj, indent=4)
     if "\n" in result:
         return f"\n{textwrap.indent(result, ' '*4)}"


Test patch:
Repository: pytorch/torchdynamo

Issue:
Mutation bug
Modifying an output after use creates a cyclical reference. E.g in the code below:
```

def forward(self, arg0_1, arg1_1, arg2_1):
    relu = torch.ops.aten.relu.default(arg2_1);  arg2_1 = None
    permute = torch.ops.aten.permute.default(arg0_1, [1, 0])
    addmm = torch.ops.aten.addmm.default(arg1_1, relu, permute);  permute = None
   ....
    copy__1 = torch.ops.aten.copy_.default(arg1_1, add_1);  arg1_1 = add_1 = None
    return ()

```
This triggers a bug in the scheduler while computing dependencies.


Chatted with @jansel about this and he suggested I remove this code block: 
https://github.com/pytorch/torchdynamo/blob/64980a6c55e39f4a727f5b16b781478167300c59/torchinductor/lowering.py#L2853

Removing the code above fixed the issue.


Discussion:
Should functionalization get rid of those? We turn on functionalization only when backward is required though, cc @Chillee 
Yeah, we currently only use functionalization for autograd (so we can partition haha).

Should we turn on functionalization for forwards only as well?

Resolving patch:
diff --git a/torchinductor/ir.py b/torchinductor/ir.py
--- a/torchinductor/ir.py
+++ b/torchinductor/ir.py
@@ -3188,6 +3188,11 @@ def create(data):
 
 
 class StorageBox(MutableBox):
+    def is_input_buffer(self):
+        if isinstance(self.data, (InputBuffer, ReinterpretView)):
+            return self.data.get_name() in V.graph.graph_inputs
+        return False
+
     def realize(self):
         if isinstance(
             self.data, (ComputedBuffer, InputsKernel, InputBuffer, ReinterpretView)
diff --git a/torchinductor/lowering.py b/torchinductor/lowering.py
--- a/torchinductor/lowering.py
+++ b/torchinductor/lowering.py
@@ -2884,7 +2884,7 @@ def mutate_to(changed, val):
         ).data
         assert isinstance(val, ir.StorageBox)
 
-    if isinstance(changed_data, ir.StorageBox):
+    if isinstance(changed_data, ir.StorageBox) and not changed_data.is_input_buffer():
         # Fast path, just swing the data pointer
         val.realize()
         changed_data.data = val.data


Test patch:
diff --git a/test/test_torchinductor.py b/test/test_torchinductor.py
--- a/test/test_torchinductor.py
+++ b/test/test_torchinductor.py
@@ -2441,6 +2441,20 @@ def fn(a):
         self.assertTrue(same(actual1, correct1))
         self.assertTrue(same(arg1, arg2))
 
+    def test_input_mutation4(self):
+        def fn(a):
+            torch.relu_(a)
+            return a
+
+        arg1 = torch.randn([1, 64], device=self.device)
+        arg2 = arg1.clone()
+        correct1 = fn(arg1)
+        opt_fn = torchdynamo.optimize_assert(compile_fx)(fn)
+        actual1 = opt_fn(arg2)
+
+        self.assertTrue(same(actual1, correct1))
+        self.assertTrue(same(arg1, arg2))
+
     @patch.object(functorch_config, "use_fake_tensor", True)
     def test_slice_mutation1(self):
         def fn(a):
Repository: pytorch/torchdynamo

Issue:
Remove the triton dependency of Inductor CPU codegen
We import triton library even we compile the CPU codegen, e.g:
```
from ctypes import c_void_p, c_long
import torch
import random
from torch import empty_strided, as_strided, device
from torchinductor.codecache import AsyncCompile

aten = torch.ops.aten
async_compile = AsyncCompile()

import triton
import triton.language as tl
from torchinductor.triton_ops.autotune import grid
from torch._C import _cuda_getCurrentRawStream as get_cuda_stream


kernel0 = async_compile.cpp('''
#include "/tmp/torchinductor_ybliang/i5/ci5zbqbzeij2usetynv7oczewshegubkvtpswwuumpp6xjync55y.h"
extern "C" void kernel(const float* __restrict__ in_ptr0,
                       const float* __restrict__ in_ptr1,
                       float* __restrict__ out_ptr0,
                       const long ks0)
{
    #pragma GCC ivdep
    for(long i0=0; i0<ks0*ks0; ++i0)
    {
        {
            {
                auto tmp0 = in_ptr0[i0];
                auto tmp1 = in_ptr1[i0];
                auto tmp2 = tmp0 + tmp1;
                out_ptr0[i0] = tmp2;
            }
        }
    }
}
''')
```
This will cause dependency issue if users just want to use inductor on CPU. I think we should remove this dependency. Look at the code [here](https://github.com/pytorch/torchdynamo/blob/main/torchinductor/codegen/wrapper.py#L198), actually we add these headers according if ```has_triton```, maybe we should define a better criteria. 


Discussion:
Already discussed offline, I think you can just expand the triton check to include a torch.cuda enabled check. 

Resolving patch:
diff --git a/torchinductor/utils.py b/torchinductor/utils.py
--- a/torchinductor/utils.py
+++ b/torchinductor/utils.py
@@ -26,6 +26,8 @@
 
 @functools.lru_cache(None)
 def has_triton():
+    if not torch.cuda.is_available():
+        return False
     try:
         import triton
 


Test patch:
Repository: pytorch/torchdynamo

Issue:
[inductor] tts_angular - bad accuracy for `select_scatter`
Repro

~~~

import torch
from torch import tensor, device
import torch.fx as fx
from torchdynamo.testing import rand_strided
from math import inf
from torch.fx.experimental.proxy_tensor import make_fx

# torch version: 1.14.0a0+git65b4080
# torch cuda version: 11.6
# torch git version: 65b408074f4ecc99faf5720ea5b3570a483ec9f4


# CUDA Info: 
# nvcc: NVIDIA (R) Cuda compiler driver 
# Copyright (c) 2005-2022 NVIDIA Corporation 
# Built on Thu_Feb_10_18:23:41_PST_2022 
# Cuda compilation tools, release 11.6, V11.6.112 
# Build cuda_11.6.r11.6/compiler.30978841_0 

# GPU Hardware Info: 
# NVIDIA A100-SXM4-40GB : 8 


from torch.nn import *
class Repro(torch.nn.Module):
    def __init__(self):
        super().__init__()

    
    
    def forward(self, add, new_zeros):
        select_scatter = torch.ops.aten.select_scatter.default(new_zeros, add, 1, -1);  new_zeros = add = None
        return (select_scatter,)
        
args = [((2, 256), (256, 1), torch.float32, 'cuda'), ((2, 50, 256), (12800, 256, 1), torch.float32, 'cuda')]
args = [rand_strided(sh, st, dt, dev) for (sh, st, dt, dev) in args]
mod = make_fx(Repro().to(device="cuda"))(*args)

from torchinductor.compile_fx import compile_fx_inner
from torchdynamo.debug_utils import same_two_models

compiled = compile_fx_inner(mod, args)
assert same_two_models(mod, compiled, args, only_fwd=True), "Accuracy failed"
~~~

cc @desertfire @SherlockNoMad 


Discussion:

Resolving patch:
diff --git a/torchinductor/lowering.py b/torchinductor/lowering.py
--- a/torchinductor/lowering.py
+++ b/torchinductor/lowering.py
@@ -1207,6 +1207,10 @@ def select_scatter(x, src, dim: int, index: int):
     assert x.get_dtype() == src.get_dtype()
     x_loader = x.make_loader()
     dim = _validate_dim(x, dim, 0)
+    if index < 0:
+        index = index + x.get_size()[dim]
+    V.graph.sizevars.guard_leq(0, index)
+    V.graph.sizevars.guard_lt(index, x.get_size()[dim])
     src = expand(unsqueeze(src, dim), x.get_size())
     src_loader = src.make_loader()
 
@@ -1214,7 +1218,7 @@ def inner_fn(idx):
         return ops.where(
             ops.eq(
                 ops.index_expr(idx[dim], torch.int32),
-                ops.constant(index, torch.int32),
+                ops.index_expr(index, torch.int32),
             ),
             src_loader(idx),
             x_loader(idx),


Test patch:
diff --git a/test/inductor/test_torchinductor_opinfo.py b/test/inductor/test_torchinductor_opinfo.py
--- a/test/inductor/test_torchinductor_opinfo.py
+++ b/test/inductor/test_torchinductor_opinfo.py
@@ -403,6 +403,7 @@ def wrapper_set_seed(op, *args, **kwargs):
     "index_put",
     "index_copy",
     "scatter_reduce.sum",
+    "select_scatter",
 }
Repository: openshift/openshift-ansible

Issue:
SDN MTU option for Openshift node config
PR: https://github.com/openshift/origin/pull/4101 (will be merged soon) introduces MTU option.

Old node config:

```
....
networkPluginName: ""
....
```

New node config:

```
...
networkConfig:
   mtu: 1450
   networkPluginName: ""
...
```

Please update your templates.



Discussion:

Resolving patch:
diff --git a/roles/openshift_facts/library/openshift_facts.py b/roles/openshift_facts/library/openshift_facts.py
--- a/roles/openshift_facts/library/openshift_facts.py
+++ b/roles/openshift_facts/library/openshift_facts.py
@@ -488,6 +488,10 @@ def set_sdn_facts_if_unset(facts):
         if 'sdn_host_subnet_length' not in facts['master']:
             facts['master']['sdn_host_subnet_length'] = '8'
 
+    if 'node' in facts:
+        if 'sdn_mtu' not in facts['node']:
+            facts['node']['sdn_mtu'] = '1450'
+
     return facts
 
 def format_url(use_ssl, hostname, port, path=''):


Test patch: